一、java多线程基本入门
java多线程编程还是比较重要的，在实际业务开发中经常要遇到这个问题。 java多线程，传统创建线程的方式有两种。
1、继承自Thread类，覆写run方法。
2、实现Runnable接口，实现run方法。
启动线程的方法都是调用start方法，真正执行调用的是run方法。
参考代码如下：
复制代码代码如下:
package com.jack.thread;
/** * 线程简单演示例子程序 * * @author pinefantasy * @since 2013-10-31 */ public class ThreadDemo1 {
/** * 第一种方式：继承自Thread类，覆写run方法 */ public static class Test1Thread extends Thread {
@Override public void run() { for (int i = 0; i < 100; i++) { System.out.println("Test1," + Thread.currentThread().getName() + ", i = " + i); } } }
/** * 第二种方式：实现Runnable接口，实现run方法 */ public static class Test2Thread implements Runnable {
@Override public void run() { for (int i = 0; i < 100; i++) { System.out.println("Test2," + Thread.currentThread().getName() + ", i = " + i); } }
}
/** * <pre> * * 主线程为main线程 * 分支线程为：1 2 3 三种简单实现方式 * * @param args */ public static void main(String[] args) { new Test1Thread().start();// 启动线程1 new Thread(new Test2Thread()).start();// 启动线程2 new Thread(new Runnable() {
@Override public void run() { for (int i = 0; i < 100; i++) { System.out.println("Test3," + Thread.currentThread().getName() + ", i = " + i); } } }).start();// 启动线程3 }
}
二、java并发包简单入门 多个线程，统一处理同一个变量演示代码：
复制代码代码如下:
package com.jack.thread;
import java.util.concurrent.atomic.AtomicInteger;
/** * 多线程对同一个变量进行操作 * * @author pinefantasy * @since 2013-10-31 */public class ThreadDemo2 {
private static int count = 0;
public static class CountThread implements Runnable {// 1.这边有线程安全问题，共享变量乱套了
@Override public void run() { for (int i = 0; i < 100; i++) { try { Thread.sleep(50); } catch (InterruptedException e) { e.printStackTrace(); } count++; System.out.println(Thread.currentThread().getName() + ", count = " + count); } }
}
private static final Object lock = new Object();// 这边使用的lock对象
public static class Count2Thread implements Runnable {// 这边使用的是互斥锁方式
@Override public void run() { synchronized (lock) {// 使用互斥锁方式处理 for (int i = 0; i < 100; i++) { count++; System.out.println(Thread.currentThread().getName() + ", count = " + count); } } }
}
private static AtomicInteger ai = new AtomicInteger();// 这边使用的是并发包的AtomicXXX类，使用的是CAS方式：compare and swap
public static class Count3Thread implements Runnable {// AtomicInteger内部的CAS实现方式，采用的是：循环、判断、设置三部曲方式
@Override public void run() { for (int i = 0; i < 100; i++) { int tmp = ai.incrementAndGet();// 采用CAS方式处理 System.out.println(Thread.currentThread().getName() + ", count = " + tmp); } }
}
private static volatile int countV = 0;// 定义成volatile，让多线程感知，因为值是放在主存中
public static class Count4Thread implements Runnable {// volatile定义的变量只是说放到了主存，当时++操作并不是原子操作，这个要小心
@Override public void run() { for (int i = 0; i < 100; i++) { try { Thread.sleep(50);// 这边让线程休眠下，增加出错概率 } catch (InterruptedException e) { e.printStackTrace(); } countV++;// volatile要正确使用，不是说定义成volatile就是安全的，还是要注意++ --操作并不是原子操作 System.out.println(Thread.currentThread().getName() + ", count = " + countV); } }
}
/** * 使用泛型简单编写一个测试方法 * * @param <T> * @param t * @throws InstantiationException * @throws IllegalAccessException * @throws InterruptedException */ public static <T> void testTemplate(T t) throws InstantiationException, IllegalAccessException, InterruptedException { for (int i = 0; i < 5; i++) { if (t instanceof Runnable) { Class<?> c = t.getClass(); Object object = c.newInstance(); new Thread((Runnable) object).start(); } } }
/** * <pre> * 1.test1 线程不安全演示例子，count变量不能得到预期的效果 * 2.test2 在test1基础上改进的，用互斥锁sync处理 * 3.test3 在test1基础上改进的，用AtomicInteger类来实现 * 4.test4 有问题的方法，因为i++并不是原子操作，将count定义为volatile类型的 * * @param args * @throws InterruptedException * @throws IllegalAccessException * @throws InstantiationException */ public static void main(String[] args) throws InterruptedException, InstantiationException, IllegalAccessException { // 1.测试1 // testTemplate(new CountThread()); // 2.测试2 // testTemplate(new Count2Thread()); // 3.测试3 // testTemplate(new Count3Thread()); // 4.测试4 testTemplate(new Count4Thread()); Thread.sleep(15000); System.out.println(count); System.out.println(ai.get()); System.out.println(countV); }
}
生产者-消费者模式 生产者（生成产品的线程）--》负责生成产品 消费者（消费产品的线程）--》负责消费产品 买车人、消费者。 卖车人、销售汽车的人、姑且当做生产者。 仓库、存放汽车的地方。 汽车工厂、真实生成汽车的地方。 参考代码如下： // 没有加上同步机制的代码如下：
复制代码代码如下:
package com.jack.thread;
import java.util.ArrayList; import java.util.List; import com.jack.thread.ThreadDemo3.CarBigHouse.Car;
/** * 第一个版本的生产者和消费者线程 * * @author pinefantasy * @since 2013-11-1 */ public class ThreadDemo3 {
/** * 姑且卖车的当做是生产者线程 */ public static class CarSeller implements Runnable {
private CarBigHouse bigHouse;
public CarSeller(CarBigHouse bigHouse) { this.bigHouse = bigHouse; }
@Override public void run() { for (int i = 0; i < 100; i++) {// 当做生产者线程，往仓库里边增加汽车，其实是触发增加汽车 int count = bigHouse.put(); System.out.println("生产汽车-->count = " + count); } }
}
/** * 姑且买车的人当做是消费者线程 */ public static class Consumer implements Runnable {
private CarBigHouse bigHouse;
public Consumer(CarBigHouse bigHouse) { this.bigHouse = bigHouse; }
@Override public void run() { for (int i = 0; i < 100; i++) {// 当做消费者线程，从仓库里边提取汽车，其实是触发，从仓库里边提取一辆汽车出来 int count = bigHouse.get(); System.out.println("消费汽车-->count = " + count); } }
}
/** * 这边姑且当做是车子big house放车子的仓库房 */ public static class CarBigHouse {
public int carNums = 0;// 这边是仓库房子中车子的数量总数 public List<Car> carList = new ArrayList<Car>();// 这边模拟用来放汽车的list
public int put() {// 提供给生产者放汽车到仓库的接口 Car car = CarFactory.makeNewCar(); carList.add(car);// 加到仓库中去 carNums++;// 总数增加1 return carNums; }
public int get() {// 提供给消费者从这边取汽车接口 Car car = null; if (carList.size() != 0) {// size不为空才去取车 car = carList.get(carList.size() - 1);// 提取最后一个car carList.remove(car);// 从从库list中移除掉 carNums--;// 总数减少1 } return carNums; }
public static class Car {
public String carName;// 汽车名称 public double carPrice;// 汽车价格
public Car() { }
public Car(String carName, double carPrice) { this.carName = carName; this.carPrice = carPrice; } } }
/** * 采用静态工厂方式创建car对象，这个只是简单模拟，不做设计模式上的过多考究 */ public static class CarFactory {
private CarFactory() { }
public static Car makeNewCar(String carName, double carPrice) { return new Car(carName, carPrice); }
public static Car makeNewCar() { return new Car(); } }
/** * 第一个版本的生产者和消费者线程，没有加上同步机制的演示例子 * * @param args */ public static void main(String[] args) { CarBigHouse bigHouse = new CarBigHouse(); new Thread(new CarSeller(bigHouse)).start(); new Thread(new Consumer(bigHouse)).start(); }
}
// 加上互斥锁的代码如下：
复制代码代码如下:
package com.jack.thread;
import java.util.ArrayList; import java.util.List; import com.jack.thread.ThreadDemo4.CarBigHouse.Car;
/** * 第二个版本的生产者消费者线程 * * @author pinefantasy * @since 2013-11-1 */ public class ThreadDemo4 {
/** * 姑且卖车的当做是生产者线程 */ public static class CarSeller implements Runnable {
private CarBigHouse bigHouse;
public CarSeller(CarBigHouse bigHouse) { this.bigHouse = bigHouse; }
@Override public void run() { for (int i = 0; i < 100; i++) {// 当做生产者线程，往仓库里边增加汽车，其实是触发增加汽车 int count = bigHouse.put(); System.out.println("生产汽车-->count = " + count); } }
}
/** * 姑且买车的人当做是消费者线程 */ public static class Consumer implements Runnable {
private CarBigHouse bigHouse;
public Consumer(CarBigHouse bigHouse) { this.bigHouse = bigHouse; }
@Override public void run() { for (int i = 0; i < 100; i++) {// 当做消费者线程，从仓库里边提取汽车，其实是触发，从仓库里边提取一辆汽车出来 int count = bigHouse.get(); System.out.println("消费汽车-->count = " + count); } }
}
/** * 这边姑且当做是车子big house放车子的仓库房 */ public static class CarBigHouse {
public int carNums = 0;// 这边是仓库房子中车子的数量总数 public List<Car> carList = new ArrayList<Car>();// 这边模拟用来放汽车的list // 直接增加上synchronized关键字方式，成员方法，锁的是当前bigHouse对象 // 这种锁是互斥锁，方法在同一个时刻，只有一个线程可以访问到里边的代码
public synchronized int put() {// 提供给生产者放汽车到仓库的接口 Car car = CarFactory.makeNewCar(); carList.add(car);// 加到仓库中去 carNums++;// 总数增加1 return carNums; }
public synchronized int get() {// 提供给消费者从这边取汽车接口 Car car = null; if (carList.size() != 0) {// size不为空才去取车 car = carList.get(carList.size() - 1);// 提取最后一个car carList.remove(car);// 从从库list中移除掉 carNums--;// 总数减少1 } return carNums; }
public static class Car {
public String carName;// 汽车名称 public double carPrice;// 汽车价格
public Car() { }
public Car(String carName, double carPrice) { this.carName = carName; this.carPrice = carPrice; } } }
/** * 采用静态工厂方式创建car对象，这个只是简单模拟，不做设计模式上的过多考究 */ public static class CarFactory {
private CarFactory() { }
public static Car makeNewCar(String carName, double carPrice) { return new Car(carName, carPrice); }
public static Car makeNewCar() { return new Car(); } }
/** * 第二个版本的生产者和消费者线程，加上了同步机制的方法 * * @param args */ public static void main(String[] args) { CarBigHouse bigHouse = new CarBigHouse(); new Thread(new CarSeller(bigHouse)).start(); new Thread(new Consumer(bigHouse)).start(); }
}
/ 采用Object类的wait和notify方法或者notifyAll方法（注意notify方法和notifyAll方法区别） // notify是唤醒其中一个在等待的线程。 // notifyAll是唤醒其他全部在等待的线程，但是至于哪个线程可以获得到锁还是要看竞争关系。 线程状态：创建、运行、阻塞、销毁状态。（阻塞情况比较多，比如等待数据IO输入，阻塞了。）
复制代码代码如下:
package com.jack.thread;
import java.util.ArrayList; import java.util.List; import com.jack.thread.ThreadDemo4.CarBigHouse.Car;
/** * 第二个版本的生产者消费者线程 * * @author pinefantasy * @since 2013-11-1 */ public class ThreadDemo4 {
/** * 姑且卖车的当做是生产者线程 */ public static class CarSeller implements Runnable {
private CarBigHouse bigHouse;
public CarSeller(CarBigHouse bigHouse) { this.bigHouse = bigHouse; }
@Override public void run() { for (int i = 0; i < 100; i++) {// 当做生产者线程，往仓库里边增加汽车，其实是触发增加汽车 int count = bigHouse.put(); System.out.println("生产汽车-->count = " + count); } }
}
/** * 姑且买车的人当做是消费者线程 */ public static class Consumer implements Runnable {
private CarBigHouse bigHouse;
public Consumer(CarBigHouse bigHouse) { this.bigHouse = bigHouse; }
@Override public void run() { for (int i = 0; i < 100; i++) {// 当做消费者线程，从仓库里边提取汽车，其实是触发，从仓库里边提取一辆汽车出来 int count = bigHouse.get(); System.out.println("消费汽车-->count = " + count); } }
}
/** * 这边姑且当做是车子big house放车子的仓库房 */ public static class CarBigHouse {
public int carNums = 0;// 这边是仓库房子中车子的数量总数 public List<Car> carList = new ArrayList<Car>();// 这边模拟用来放汽车的list public static final int max = 100;// 简单设置下，做下上限设置
private Object lock = new Object();// 采用object的wait和notify方式处理同步问题
public int put() {// 提供给生产者放汽车到仓库的接口 synchronized (lock) { if (carList.size() == max) {// 达到了上限，不再生产car try { lock.wait();// 进行阻塞处理 } catch (InterruptedException e) { e.printStackTrace(); } } Car car = CarFactory.makeNewCar(); carList.add(car);// 加到仓库中去 carNums++;// 总数增加1 lock.notify();// 唤醒等待的线程 return carNums; } }
public int get() {// 提供给消费者从这边取汽车接口 Car car = null; synchronized (lock) { if (carList.size() == 0) {// 没有汽车可以用来消费 try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } if (carList.size() != 0) {// size不为空才去取车 car = carList.get(carList.size() - 1);// 提取最后一个car carList.remove(car);// 从从库list中移除掉 carNums--;// 总数减少1 } lock.notify(); return carNums; } }
public static class Car {
public String carName;// 汽车名称 public double carPrice;// 汽车价格
public Car() { }
public Car(String carName, double carPrice) { this.carName = carName; this.carPrice = carPrice; } } }
/** * 采用静态工厂方式创建car对象，这个只是简单模拟，不做设计模式上的过多考究 */ public static class CarFactory {
private CarFactory() { }
public static Car makeNewCar(String carName, double carPrice) { return new Car(carName, carPrice); }
public static Car makeNewCar() { return new Car(); } }
/** * 第二个版本的生产者和消费者线程，加上了同步机制的方法 * * @param args */ public static void main(String[] args) { CarBigHouse bigHouse = new CarBigHouse(); new Thread(new CarSeller(bigHouse)).start(); new Thread(new Consumer(bigHouse)).start(); }
}
