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.****.net/u012954390/article/details/51301873，我只是稍作了修改。