JUC的等待唤醒机制(wait/notify await/singal)之生产者和消费者问题

生产者消费者问题是线程模型中的经典问题：生产者和消费者在同一时间段内共用同一存储空间，生产者向空间里生产数据，而消费者取走数据。

阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。这个阻塞队列就是用来给生产者和消费者解耦的。

一、生产者消费者实现-Object/wait/notify

精简就是：线程操作资源类

仿照官方jdk的文档写：

import java.util.ArrayList;
import java.util.List;

/**
 * @author zhangzhixi
 * @date 2021-4-23 13:38
 */
public class Demo_06_生产者和消费者_实现1 {
    public static void main(String[] args) {
        List list = new ArrayList();
        Resources1 resources1 = new Resources1(list);
        new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                resources1.increment();
            }
        }, "生产").start();

        new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                resources1.decrease();
            }
        }, "消费").start();
    }
}

/**
 * 资源类
 */
class Resources1 {
    /**模拟要进行操作的数据*/
    private List list;

    public Resources1() {
    }

    public Resources1(List list) {
        this.list = list;
    }

    /**
     * 生产者线程
     */
    public void increment() {
        // 1、判断
        synchronized (list) {
            while (list.size() != 0) {
                try {
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 2、执行添加数据操作(生产)
            Object obj = new Object();
            list.add(obj);
            System.out.println(Thread.currentThread().getName() + "==>" + obj);
            // 3、通知唤醒，提醒消费者进行消费
            list.notify();
        }
    }

    /**
     * 消费者线程
     */
    public void decrease() {
        // 1、判断
        synchronized (list) {
            while (list.size() == 0) {
                try {
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 2、执行移除数据操作
            Object obj = list.remove(0);
            System.out.println(Thread.currentThread().getName() + "==>" + obj);
            // 3、通知唤醒，提醒生产者进行生产
            list.notify();
        }
    }
}

测试：

二、 生产者消费者实现：Lock/await/signal

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

/**
 * @author zhangzhixi
 * @date 2021-4-23 14:37
 */
public class Demo_06_生产者和消费者_实现2 {
    public static void main(String[] args) {
        Resources2 resources2 = new Resources2();
        new Thread(()->{
            try {
                for (int i = 0; i < 5; i++) {
                    resources2.increment();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"生产者").start();

        new Thread(()->{
            try {
                for (int i = 0; i < 5; i++) {
                    resources2.decrease();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"消费者").start();
    }
}

class Resources2 {
    int number = 0;
    private Lock lock = new ReentrantLock();
    //返回绑定到此Lock实例的新Condition实例
    Condition condition = lock.newCondition();

    public void increment() throws InterruptedException {
        lock.lock();
        try {
            // 1、判断
            while (number != 0) {
                // 使当前线程等待
                condition.await();
            }
            // 2、执行操作
            number++;
            System.out.println(Thread.currentThread().getName() + "==>" + number);
            // 3、唤醒消费线程进行消费
            condition.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void decrease() throws InterruptedException {
        lock.lock();
        try {
            // 1、判断
            while (number == 0) {
                // 使当前线程等待
                condition.await();
            }
            // 2、执行操作
            number--;
            System.out.println(Thread.currentThread().getName() + "==>" + number);
            // 3、唤醒生产者进行生产
            condition.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

测试：

 三、面试题：Synchronized跟Lock有什么区别，使用Lock的好处是什么

1.原始构成：

Synchronized是属于JVM层面上面的锁，是java中的一个关键字

reentrantLock是属于API层面上面的锁（java.util.concurrent.locks.lock）　　

2.使用方法

Synchronized不需要程序员手动去释放锁，在线程执行结束后，系统会自动让线程释放对锁的占用

reentrantLock是需要程序员手动添加与释放锁的，如果没有释放锁就会出现死锁的情况

　　通常是需要：wait/notify...try/finally语句块进行使用

3.等待是否可中断

Synchronized：不可中断，除非抛出异常，或者程序正常执行完毕

reentrantLock：可以中断：

　　1.设置超时方法：tryLock(long time,TimeUnit unit)：

 　　2.lockInterruptibly()放入代码块中，调用interrupted解锁

4.加锁是否公平

Synchronized：默认非公平锁

reentrantLock：两者都可以，默认的是非公平锁

5.锁绑定多个条件：condition

Synchronized：没有

reentrantLock：可以精确唤醒

四、绑定多个条件：Condition，精准唤醒

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

/**
 * @author zhangzhixi
 * @date 2021-4-23 22:16
 */
public class Demo_07_绑定多个条件_Condition {
    public static void main(String[] args) {
        // 线程操作资源类
        ResourceClass resourceClass = new ResourceClass();
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                resourceClass.print5();
            }
        }, "A").start();

        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                resourceClass.print10();
            }
        }, "B").start();

        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                resourceClass.print15();
            }
        }, "C").start();
    }
}

/**
 * 题目:多线程之间按顺序调用，实现A->B->C三 个线程启动，要求如下:
 * AA打印5次，BB打印10次，CC打印15次
 * 紧接着.
 * AA打印5次，BB打印10次, CC打印15次
 * 来10轮
 */
class ResourceClass {
    // 唤醒执行的线程：A:1 B:2 c:3
    private int number = 1;
    Lock lock = new ReentrantLock();
    Condition c1 = lock.newCondition();
    Condition c2 = lock.newCondition();
    Condition c3 = lock.newCondition();

    public void print5() {
        lock.lock();
        try {
            // 1、判断
            while (number != 1) {
                c1.await();
            }
            // 2、干活
            for (int i = 1; i <= 5; i++) {
                System.out.println(Thread.currentThread().getName() + "==>" + i);
            }
            // 标志位
            number = 2;
            // 3、通知2号线程
            c2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void print10() {
        lock.lock();
        try {
            // 1、判断
            while (number != 2) {
                c2.await();
            }
            // 2、干活
            for (int i = 1; i <= 10; i++) {
                System.out.println(Thread.currentThread().getName() + "==>" + i);
            }
            // 标志位
            number = 3;
            // 3、通知3号线程
            c3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void print15() {
        lock.lock();
        try {
            // 1、判断
            while (number != 3) {
                c3.await();
            }
            // 2、干活
            for (int i = 1; i <= 15; i++) {
                System.out.println(Thread.currentThread().getName() + "==>" + i);
            }
            // 标志位
            number = 1;
            // 3、通知1号线程
            c1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}