生产者消费者模型的实现

等待队列使用Condition生成两个等待队列，分别是生产者等待队列和消费者等待队列，并分别使用await()和signalAll()进行置入等待和唤醒操作，使用new ConcurrentLinkedDeque()作为货品队列，使用名为cargo的字符串"cargo"作为货物单品，使用Executors.newFixedThreadPool(5)生成一个大小为5的固定大小的线程池。
下面是代码实现：
生产者消费者交互模块：

import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedDeque;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Y
 * Date: 2019-07-06
 * Time: 12:52
 */
public class Service {
    private Lock lock = new ReentrantLock();
    private Condition conditionp = lock.newCondition();
    private Condition conditionc = lock.newCondition();
    private Queue queue = new ConcurrentLinkedDeque();
    private Object cargo = "cargo";//货物

    public void producer() {
        lock.lock();
        try {
            while (queue.size() == 5) {
                System.out.println("生产者" + Thread.currentThread().getName() + "进入生产者等待队列");
                conditionc.signalAll();
                conditionp.await();
            }

            queue.offer(cargo);
            System.out.println("生产者" + Thread.currentThread().getName() + "生产货物，目前存货量为" + queue.size());
            conditionp.awaitNanos(100);
            conditionc.awaitNanos(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void consumer() {
        lock.lock();

        try {
            while (queue.isEmpty()) {
                System.out.println("消费者" + Thread.currentThread().getName() + "进入消费者等待队列");
                conditionp.signalAll();
                conditionc.await();
            }
            queue.poll();
            System.out.println("消费者" + Thread.currentThread().getName() + "消费了货物，目前存货量为" + queue.size());
            conditionp.awaitNanos(100);
            conditionc.awaitNanos(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

生产者线程模块

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Y
 * Date: 2019-07-06
 * Time: 12:52
 */
public class ProduceThread extends Thread {
    Service servicep=new Service();
    public ProduceThread(Service servicep){
        this.servicep=servicep;
    }
    @Override
    public void run() {
        while (true){
            servicep.producer();
        }
    }
}

消费者线程模块

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Y
 * Date: 2019-07-06
 * Time: 12:53
 */
public class CosumeThread extends  Thread {
    Service servicec=new Service();
    public CosumeThread(Service servicec){
        this.servicec=servicec;
    }

    @Override
    public void run() {
        while (true){
            servicec.consumer();
        }
    }
}

主函数模块

import java.util.concurrent.*;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Y
 * Date: 2019-07-06
 * Time: 12:53
 */
public class Main {
    public static void main(String[] args) {
        Service service = new Service();
        Executor executor = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 5; i++) {
            ProduceThread produceThread=new ProduceThread(service);
            executor.execute(produceThread);
            CosumeThread cosumeThread=new CosumeThread(service);
            executor.execute(cosumeThread);
        }
        ((ExecutorService) executor).shutdown();
    }

}

下面是运行结果：