java多线程的简单demo
模拟场景：顾客买车从车库中取车，厂家生产车，车存储在车库中。买家、厂家对同一个车库中的车操作
一、不加同步机制的代码如下：
package com.joysuch.testng.thread; import java.util.ArrayList; import java.util.List; import com.joysuch.testng.thread.ThreadDemo1.CarHouse.Car; /** * @author ning * 创建于 2017年11月22日上午11:25:29 * //TODO (没有加上同步机制) */ public class ThreadDemo1 { /** * @author ning * 创建于 2017年11月22日上午11:27:53 * //TODO 卖车的当做生产者线程 */ public static class CarSeller implements Runnable { private CarHouse carHouse; public CarSeller(CarHouse carHouse){ this.carHouse = carHouse; } @Override public void run() { for (int i = 0; i < 10; i++) {// 当做生产者线程，往仓库里边增加汽车，其实是触发增加汽车 carHouse.put(i); } } } /** * @author ning * 创建于 2017年11月22日上午11:29:00 * //TODO 购买者当做消费者线程 */ public static class Consumer implements Runnable { private CarHouse carHouse; public Consumer(CarHouse carHouse){ this.carHouse = carHouse; } @Override public void run() { for (int i = 0; i < 10; i++) {// 当做消费者线程，从仓库里边提取汽车，其实是触发，从仓库里边提取一辆汽车出来 carHouse.get(i); } } } /** * @author ning * 创建于 2017年11月22日上午11:30:22 * //TODO 汽车仓库 */ public static class CarHouse { /** * 车库中汽车数量 */ public Integer carNums = 0; public Integer getCarNums() { return carNums; } public void setCarNums(Integer carNums) { this.carNums = carNums; } public List<Car> getCarList() { return carList; } public void setCarList(List<Car> carList) { this.carList = carList; } /** * 存放汽车的集合 */ public List<Car> carList = new ArrayList<>(); public int put(int i){ Car car = CarFactory.makeNewCar(); carList.add(car); carNums++; System.out.println("生产汽车-" + i + "->车库汽车数量---count = " + carList.size()); return carList.size(); } public int get(int i){ Car car = null; if(carList.size() > 0){ car = carList.get(carList.size() - 1); carList.remove(car); carNums--; } System.out.println("消费汽车-" + i + "->车库汽车数量---count = " + carList.size()); return carList.size(); } public static class Car { public String carName; public double carPrice; public Car(){} public Car(String carName, Double carPrice){ this.carName = carName; this.carPrice = carPrice; } public String getCarName() { return carName; } public void setCarName(String carName) { this.carName = carName; } public double getCarPrice() { return carPrice; } public void setCarPrice(double carPrice) { 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) { CarHouse bigHouse = new CarHouse(); new Thread(new CarSeller(bigHouse)).start(); new Thread(new Consumer(bigHouse)).start(); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(bigHouse.getCarNums()); System.out.println(bigHouse.getCarList().size()); } }
运行结果产生的错读如下：
消费汽车-0->车库汽车数量---count = 0 消费汽车-1->车库汽车数量---count = 0 消费汽车-2->车库汽车数量---count = 0 消费汽车-3->车库汽车数量---count = 0 消费汽车-4->车库汽车数量---count = 0 消费汽车-5->车库汽车数量---count = 0 消费汽车-6->车库汽车数量---count = 0 消费汽车-7->车库汽车数量---count = 0 消费汽车-8->车库汽车数量---count = 0 消费汽车-9->车库汽车数量---count = 0 生产汽车-0->车库汽车数量---count = 1 生产汽车-1->车库汽车数量---count = 1 生产汽车-2->车库汽车数量---count = 2 生产汽车-3->车库汽车数量---count = 3 生产汽车-4->车库汽车数量---count = 4 生产汽车-5->车库汽车数量---count = 5 生产汽车-6->车库汽车数量---count = 6 生产汽车-7->车库汽车数量---count = 7 生产汽车-8->车库汽车数量---count = 8 生产汽车-9->车库汽车数量---count = 9 9 9
从上面的结果可以看出，在生产了一次汽车之后，车库汽车数量为1，然后生产第2次的时候，车库汽车数量仍为1，显然是不正确的。可能是线程再执行最后一次消费汽车时，还没执行完，第一次的生成汽车就执行了，导致车库汽车数量又从1变成了0。所以第2次执行生成汽车的时候，结果车库数量为1。
二、加上互斥锁
代码如下：
package com.joysuch.testng.thread; import java.util.ArrayList; import java.util.List; import java.util.concurrent.locks.ReentrantLock; import com.joysuch.testng.thread.ThreadDemo2.CarHouse.Car; /** * @author ning * 创建于 2017年11月22日上午11:25:29 * //TODO (加上互斥锁) */ public class ThreadDemo2 { /** * @author ning * 创建于 2017年11月22日上午11:27:53 * //TODO 卖车的当做生产者线程 */ public static class CarSeller implements Runnable { private CarHouse carHouse; public CarSeller(CarHouse carHouse){ this.carHouse = carHouse; } @Override public void run() { for (int i = 0; i < 10; i++) {// 当做生产者线程，往仓库里边增加汽车，其实是触发增加汽车 carHouse.put(i); } } } /** * @author ning * 创建于 2017年11月22日上午11:29:00 * //TODO 购买者当做消费者线程 */ public static class Consumer implements Runnable { private CarHouse carHouse; public Consumer(CarHouse carHouse){ this.carHouse = carHouse; } @Override public void run() { for (int i = 0; i < 10; i++) {// 当做消费者线程，从仓库里边提取汽车，其实是触发，从仓库里边提取一辆汽车出来 carHouse.get(i); } } } /** * @author ning * 创建于 2017年11月22日上午11:30:22 * //TODO 汽车仓库 */ public static class CarHouse { /** * 车库中汽车数量 */ public Integer carNums = 0; /** * 存放汽车的集合 */ public List<Car> carList = new ArrayList<>(); public Integer getCarNums() { return carNums; } public void setCarNums(Integer carNums) { this.carNums = carNums; } public List<Car> getCarList() { return carList; } public void setCarList(List<Car> carList) { this.carList = carList; } // 直接增加上synchronized关键字方式，成员方法，锁的是当前bigHouse对象 // 这种锁是互斥锁，方法在同一个时刻，只有一个线程可以访问到里边的代码 /* public synchronized int put(int i) {// 提供给生产者放汽车到仓库的接口 Car car = CarFactory.makeNewCar(); carList.add(car);// 加到仓库中去 carNums++;// 总数增加1 System.out.println("生产汽车-" + i + "->车库汽车数量---count = " + carList.size()); return carList.size(); } public synchronized int get(int i) {// 提供给消费者从这边取汽车接口 Car car = null; if (carList.size() != 0) {// size不为空才去取车 car = carList.get(carList.size() - 1);// 提取最后一个car carList.remove(car);// 从从库list中移除掉 carNums--;// 总数减少1 } System.out.println("消费汽车-" + i + "->车库汽车数量---count = " + carList.size()); return carList.size(); } */ //Lock提供了比synchronized方法和synchronized代码块更广泛的锁定操作，Lock更灵活的结构，有很大的差别，并且可以支持多个Condition对象 Lock是控制多个线程对共享资源进行访问的工具。 //通常，锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁， 线程开始访问共享资源之前应先获得Lock对象。 //不过某些锁支持共享资源的并发访问，如：ReadWriteLock（读写锁），在线程安全控制中， 通常使用ReentrantLock（可重入锁）。使用该Lock对象可以显示加锁、释放锁。 final ReentrantLock lock = new ReentrantLock(); public int put(int i){ int size = -100; //上锁 lock.lock(); try { Car car = CarFactory.makeNewCar(); carList.add(car); carNums++; size = carList.size(); System.out.println("生产汽车-" + i + "->车库汽车数量---count = " + size); }finally{ //释放锁 lock.unlock(); } return size; } public int get(int i){ //上锁 int size = -100; lock.lock(); try{ Car car = null; if (carList.size() != 0) {// size不为空才去取车 car = carList.get(carList.size() - 1);// 提取最后一个car carList.remove(car);// 从车库list中移除掉 carNums--;// 总数减少1 } size = carList.size(); System.out.println("消费汽车 " + i + "-->车库汽车数量---count = " + size); }finally{ //释放锁 lock.unlock(); } return size; } public static class Car { public String carName; public double carPrice; public Car(){} public Car(String carName, Double carPrice){ this.carName = carName; this.carPrice = carPrice; } public String getCarName() { return carName; } public void setCarName(String carName) { this.carName = carName; } public double getCarPrice() { return carPrice; } public void setCarPrice(double carPrice) { this.carPrice = carPrice; } @Override public String toString() { return "Car [carName=" + carName + ", 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) { int x = 0; //这里为了便于查看测试结果，所以执行了多次 while(x < 50){ CarHouse bigHouse = new CarHouse(); new Thread(new CarSeller(bigHouse)).start(); new Thread(new Consumer(bigHouse)).start(); try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(bigHouse.getCarNums()); System.out.println(bigHouse.getCarList().size()); x++; } } }
鉴于结果太多，就不展示结果代码。
三、采用Object类的wait和notify方法或者notifyAll方法
代码如下：
package com.joysuch.testng.thread; import java.util.ArrayList; import java.util.List; import com.joysuch.testng.thread.ThreadDemo3.CarBigHouse.Car; /** * @ClassName: ThreadDemo3 * @Description: TODO(采用Object类的wait和notify方法或者notifyAll方法（注意notify方法和notifyAll方法区别） * notify是唤醒其中一个在等待的线程。 notifyAll是唤醒其他全部在等待的线程，但是至于哪个线程可以获得到锁还是要看竞争关系。线程状态：创建、运行、阻塞、销毁状态。（阻塞情况比较多，比如等待数据IO输入，阻塞了。）) * @author ning * @date 2017年11月22日 上午11:38:09 * */ public class ThreadDemo3 { /** * 姑且卖车的当做是生产者线程 */ public static class CarSeller implements Runnable { private CarBigHouse bigHouse; public CarSeller(CarBigHouse bigHouse) { this.bigHouse = bigHouse; } public void run() { for (int i = 0; i < 10; i++) {// 当做生产者线程，往仓库里边增加汽车，其实是触发增加汽车 bigHouse.put(); } } } /** * 姑且买车的人当做是消费者线程 */ public static class Consumer implements Runnable { private CarBigHouse bigHouse; public Consumer(CarBigHouse bigHouse) { this.bigHouse = bigHouse; } public void run() { for (int i = 0; i < 10; i++) {// 当做消费者线程，从仓库里边提取汽车，其实是触发，从仓库里边提取一辆汽车出来 bigHouse.get(); } } } /** * 这边姑且当做是车子big house放车子的仓库房 */ public static class CarBigHouse { public int carNums = 0;// 这边是仓库房子中车子的数量总数 public List<Car> carList = new ArrayList<Car>();// 这边模拟用来放汽车的list public static final int max = 3;// 简单设置下，做下上限设置 private Object lock = new Object();// 采用object的wait和notify方式处理同步问题 public int put() {// 提供给生产者放汽车到仓库的接口 synchronized (lock) { if (carList.size() == max) {// 达到了上限，不再生产car try { System.out.println("生产达到上限...阻塞处理"); lock.wait();// 进行阻塞处理 } catch (InterruptedException e) { e.printStackTrace(); } } Car car = CarFactory.makeNewCar(); carList.add(car);// 加到仓库中去 carNums++;// 总数增加1 lock.notify();// 唤醒等待的线程 System.out.println("生产汽车-->count = " + carNums); return carNums; } } public int get() {// 提供给消费者从这边取汽车接口 Car car = null; synchronized (lock) { if (carList.size() == 0) {// 没有汽车可以用来消费 try { System.out.println("没有汽车...阻塞处理"); 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(); System.out.println("消费汽车-->count = " + carNums); 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(); } }
结果展示：
生产汽车-->count = 1 生产汽车-->count = 2 生产汽车-->count = 3 生产达到上限...阻塞处理 消费汽车-->count = 2 消费汽车-->count = 1 消费汽车-->count = 0 没有汽车...阻塞处理 生产汽车-->count = 1 生产汽车-->count = 2 生产汽车-->count = 3 生产达到上限...阻塞处理 消费汽车-->count = 2 消费汽车-->count = 1 消费汽车-->count = 0 没有汽车...阻塞处理 生产汽车-->count = 1 生产汽车-->count = 2 生产汽车-->count = 3 生产达到上限...阻塞处理 消费汽车-->count = 2 消费汽车-->count = 1 消费汽车-->count = 0 没有汽车...阻塞处理 生产汽车-->count = 1 消费汽车-->count = 0
到此，简单的demo测试结束。
注：本文测试代码参考于 吖梁 http://blog.csdn.net/u012954390/article/details/51301873，我只是稍作了修改。
