Java 两个线程实现生产者和消费者的问题

先简单交代下背景，两个线程实现生产者和消费者的问题，就是给一个固定大小容器，然后生产者开始生产，消费者开始消费，容器满的时候生产者停止生产，容器为空的时候消费者停止消费，等待生产者进行生产

ReentrantLock 的Condition 使用

这里使用Condition来进行实现把，这里基本等同于synchronized的wait notify

    @Test
    public void testProduceAndConsume(){
        ReentrantLock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        int ans[] = new int[]{0};
        new Thread(()->{
            while (true){
                try {
                    lock.lock();
                    if(ans[0]==0){
                        try {
                            condition.await();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    System.out.println("消费者消费了一条数据"+ans[0]);
                    ans[0]--;
                    condition.signalAll();
                } catch (RuntimeException e) {
                    throw new RuntimeException(e);
                }finally {
                    lock.unlock();
                }
            }
        }).start();
        new Thread(()->{
            while (true){
                try {
                    lock.lock();
                    if(ans[0]==10){
                        try {
                            condition.await();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    ans[0]++;
                    System.out.println("生产者生产了一条数据"+ans[0]);
                    condition.signalAll();
                } catch (RuntimeException e) {
                    throw new RuntimeException(e);
                }finally {
                    lock.unlock();
                }
            }
        }).start();

        try {
            TimeUnit.SECONDS.sleep(10);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

这里的话就主要练习了下使用ReentrantLock的condition 来实现线程间的通信，当生产者生产了消息之后就通知消费者来进行消费，消费者消费了一条消息之后通知生产者进行生产，这里就体现在signalAll 这里，这里因为只有一个生产者和消费者，所以signal和signalAll没差别
当容器满的时候，生产者进行await，然后等待消费者进行消费，消费者同理，当容器空的时候等待生产者进行生产，因为这里在每次生产一条数据或者消费一条数据之后都会进行唤醒，所以await之前不需要唤醒了，

总结

这里的await 就等于synchronized的wait ，signal等于synchronized的notify，signalAll等于synchronized的notifyAll方法，都需要在持有锁的情况下进行使用