JUC学习之生产者和消费者

生产者和消费者问题是线程模型中的经典问题：生产者和消费者在同一时间段内共用同一个存储空间，生产者往存储空间中添加产品，消费者从存储空间中取走产品，当存储空间为空时，消费者阻塞，当存储空间满时，生产者阻塞。我们这里用信号灯的变化来模拟演示。

synchronized版：

wait() 和 notify()方法的实现，这也是最简单最基础的实现，缓冲区满和为空时都调用wait()方法等待，当生产者生产了一个产品或者消费者消费了一个产品之后会唤醒所有线程。

/**
 * 信号灯
 * 红绿两种状态
 * 一个改变颜色的方法
 */
class TrafficLight{
    private String color = "red";

    /**
     * 是，就等待
     * 不是，就执行
     * 然后，唤醒
     */
    public synchronized void change2Green() throws InterruptedException {
        while (color.equals("green")) {
            this.wait();
        }
//        TimeUnit.SECONDS.sleep(1);
        color = "green";
        System.out.println(Thread.currentThread().getName()+"==>"+color);
        this.notifyAll();
    }

    public synchronized void change2Red() throws InterruptedException {
        while (color.equals("red")) {
            this.wait();
        }
        color = "red";
        System.out.println(Thread.currentThread().getName()+"==>"+color);
        this.notifyAll();
    }

}

需要注意的是：当使用if判断时，会造成虚假唤醒，解决方法为：

Lock版：

可重入锁ReentrantLock的实现，java.util.concurrent.lock 中的 Lock 框架是锁定的一个抽象，通过对lock的lock()方法和unlock()方法实现了对锁的显示控制，而synchronize()则是对锁的隐性控制。 可重入锁，也叫做递归锁，指的是同一线程外层函数获得锁之后，内层递归函数仍然有获取该锁的代码，但不受影响，简单来说，该锁维护这一个与获取锁相关的计数器，如果拥有锁的某个线程再次得到锁，那么获取计数器就执行，函数调用结束计数器就执行，然后锁需要被释放两次才能获得真正释放。已经获取锁的线程进入其他需要相同锁的同步代码块不会被阻塞。

class TrafficLight2 {
    private String color = "red";

    /**
     * lock版本的：await（）=wait（），signal（）=notify（）
     * Condition可以单独监视一个线程，实现精准通知唤醒
     */
    Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();


    public void change2Green() throws InterruptedException {
        lock.lock();

        try {
            while (color.equals("green")) {
                condition1.await();
            }
//        TimeUnit.SECONDS.sleep(1);
            color = "green";
            System.out.println(Thread.currentThread().getName() + "==>" + color);
            condition3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void change2Red() throws InterruptedException {
        lock.lock();

        try {
            while (color.equals("red")) {
                condition2.await();
            }
            color = "red";
            System.out.println(Thread.currentThread().getName() + "==>" + color);
            condition1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void change2Yellow() throws InterruptedException {
        lock.lock();

        try {
            while (color.equals("yellow")) {
                condition3.await();
            }
            color = "yellow";
            System.out.println(Thread.currentThread().getName() + "==>" + color);
            condition2.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    
}

await（）= wait（），signal（）= notify（）

Condition可以单独监视一个线程，实现精准通知唤醒

Q.E.D.