生产者消费者多线程案例代码

Java线程中生产者与消费者的问题

一、概念

生产者与消费者问题是一个经典的多线程协作的问题.生产者负责生产产品，并将产品存放到仓库；消费者从仓库中获取产品并消费。当仓库满时，生产者必须停止生产，直到仓库有位置存放产品；当仓库空时，消费者必须停止消费，直到仓库中有产品。
　　
二、实现代码思路
　　主要用到如下几个技术：1.用线程模拟生产者，在run方法中不断地往仓库中存放产品。2.用线程模拟消费者，在run方法中不断地从仓库中获取产品。3.仓库类保存产品，当产品数量为0时，调用wait方法，使得当前消费者线程进入等待状态，当有新产品存入时，调用notify方法，唤醒等待的消费者线程。当仓库满时，调用wait方法，使得当前生产者线程进入等待状态，当有消费者获取产品时，调用notify方法，唤醒等待的生产者线程。

工厂类放置 消费者生产者方法 代码
注意理解： private volatile int apple = 0;
被volatile关键字修饰的变量，编译器与运行时都会注意到这个变量是共享的，因此不会将该变量上的操作与其他内存操作一起重排序。volatile变量不会被缓存在寄存器或者对其他处理器不可见的地方，因此在读取volatile类型的变量时总会返回最新写入的值。

比如i＝i+1，单线程操作没问题，如果使用多线程，比如两个线程，执行这段代码后（i初始值为0），i应该等于2，但是如果不用volatile修饰变量i，结果会等于1，初始时，两个线程分别读取i的值存入各自所在的CPU的高速缓存当中，然后线程1进行加1操作，然后把i的最新值1写入到内存。此时线程2的高速缓存当中i的值还是0，进行加1操作之后，i的值为1，然后线程2把i的值写入内存。

  synchronized 关键词含义： 同步锁 执行完毕自动释放锁 出现异常也会自动释放锁 主要作用多线程执行中上锁，确保唯一性

package com.macro.mall.tiny.thred;

import com.sun.javafx.iio.gif.GIFImageLoaderFactory;

public class Warehouse {

    private volatile int apple = 0;

    /**
     * 生产
     */
    public synchronized void produce(){

       if (apple==5){
           try {
               wait();
               System.out.println("仓库满了");

           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }else {
           apple++;
           System.out.println("生产苹果"+apple+"个数");
           notify();
       }

    }

    public synchronized void consumption(){

        if (apple==0){
            try {
                wait();
                System.out.println("苹果库存不够");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else {
            apple--;
            System.out.println("剩余苹果"+apple);
            notify();
        }

    }
		/**
		*测试
		**/
    public static void main(String[] args) {
        Warehouse warehouse = new Warehouse();

        Consumer con = new Consumer(warehouse);
        Producer pro = new Producer(warehouse);
        Thread t1 = new Thread(con);
        Thread t2 = new Thread(pro);
        Thread t3 = new Thread(con);
        Thread t4 = new Thread(pro);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

消费者线程 代码

public class Consumer implements Runnable {

    private Warehouse warehouse;

    public Consumer(Warehouse warehouse) {
        this.warehouse = warehouse;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            try {
                // 这里设置跟上面30不同是为了 仓库中的苹果能够增加，不会生产一个马上被消费
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            warehouse.consumption();
        }
    }
}

生产者线程代码

public class Producer implements Runnable {

    private Warehouse warehouse;

    public Producer(Warehouse warehouse) {
        this.warehouse = warehouse;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            warehouse.produce();
        }
    }
}