java多线程同步案例之--生产者消费者模型

需求：
1 同一时间内只能有一个生产者生产    

2 同一时间内只能有一个消费者消费    

3 生产者生产的同时消费者不能消费    

4 消费者消费的同时生产者不能生产 

 消费者和生产者只能有一个在工作。
 ----同步方法或者同步代码快
5 共享空间空时消费者不能继续消费    

6 共享空间满时生产者不能继续生产    

注意:
1、Wait、notify、notifyAll方法的调用必须放在同步方法和同步代码块里面
是调用“同步锁”对象的Wait、notify、notifyAll方法而不是线程对象的方法。
//定义一个仓库类

public class Storage {

    /**

     * Max_num表示仓库的最大容量

     * cur_num表示当前仓库的库存

     */

    static int Max_num = 100;

    

    private int cur_num = 50;

    

    //入库的方法
    public synchronized void in(int num){

//如果当前库存加上生产者准备存放的量大于仓库的最大容量，则将该线程挂起，释放当前进程锁

        while(this.cur_num + num > Max_num){

            try {

                System.out.println(Thread.currentThread().getName() + "入库失败，仓库已溢出！请及时消费");

                this.wait();

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

        this.notify();

        cur_num += num;

        System.out.println(Thread.currentThread().getName() + "入库" + num +",库存为：" + cur_num);

    }

    

    //出库的方法
    public synchronized void out(int num){

//如果当前消费者的需求量大于仓库的库存，则将该线程挂起，释放当前进程锁

        while(num > cur_num){

            try {

                System.out.println( Thread.currentThread().getName() + "出库失败，库存不足！请及时补货");

                this.wait();

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

        this.notify();

        cur_num -= num;

        System.out.println(Thread.currentThread().getName() + "出库" + num +",库存为：" + cur_num);
    }

//接着定义消费者线程类

public class Customer extends Thread{

    Storage s; //根据仓库的对象实现线程同步

    private int num; //当前消费者的需求量

    

    /**

     * @param name 输出当前线程名（也就是消费者名）

     * @param s    传入仓库对象

     * @param num 消费者的需求量

     */

    public Customer(String name,Storage s,int num){

        super(name);//线程名

        this.s = s;

        this.num = num;

    }

    

    public void run(){

        try {

            Thread.sleep(500);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        //调用仓库中的出库方法，将需求变量传入

        s.out(num);

    }

}

//还需定义一个生产者线程类

public class Producer extends Thread{

    Storage s; //根据仓库的对象实现线程同步

    private int num;//当生产者的生产量

    /**

     * @param name 输出当前线程名（也就是生产者名）

     * @param s    传入仓库对象

     * @param num 生产者的生产量

     */

    public Producer(String name,Storage s,int num){

        super(name); //线程名

        this.s = s;

        this.num = num;

    }

    

    public void run(){

        try {

            Thread.sleep(500);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        //调用仓库中的入库方法，将准备入库的数量传入

        s.in(num);

    }

}

//最后，创建Test类进行测试

public class Test {

    public static void main(String[] args) {

        //创建一个共同的仓库对象（注：这里因为是消费者线程和生产者线程要实现同步，所以只能new一个仓库对象）

        Storage s = new Storage();

        

        //创建生产者线程：

        /**

         * 传入线程名、对象、出入库的数量

         */

        Producer p1 = new Producer("P_1", s, 50);

        Producer p2 = new Producer("P_2", s, 20);

        Producer p3 = new Producer("P_3", s, 30);

        

        //创建消费者进程：

        Customer c1 = new Customer("C_1", s, 60);

        Customer c2 = new Customer("C_2", s, 30);

        Customer c3 = new Customer("C_3", s, 60);

        //启动线程

        p1.start();p2.start();p3.start();

        c1.start();c2.start();c3.start();      

    }

}