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();
}
}
}
