condition是什么？应用场景condition精确唤醒代码结果输出
condition是什么？JUC是Java的一个包
Package java.util.concurrent.locks
接口和类提供了一个框架，用于锁定和等待与内置同步和监视器不同的条件。
包含了三个接口，Lock、Condition、ReadWriteLock
| 接口 | 描述 |
|---|---|
| Condition | Condition因素出Object监视器方法（ wait ， notify和notifyAll ）成不同的对象，以得到具有多个等待集的每个对象，通过将它们与使用任意的组合的效果Lock个实现。 |
| Lock | Lock实现提供比使用 synchronized方法和语句可以获得的更广泛的锁定操作。 |
| ReadWriteLock | A ReadWriteLock维护一对关联的locks ，一个用于只读操作，一个用于写入。 |
线程之间的通信，线程A、B、C按次序执行?
如何去做?condition + 信号量标识去做
1.condition：使用多个同步监视器，每个监视器去监视一个资源，这样就可以保证一个调用完成之后，再去调用另一个，实现精确的控制线程访问的顺序2.信号量表示flag，作用如下：
1>定义第一个开始执行的线程：因为线程的执行是乱序的，不加while判断就无法精确的标识由那个线程开始2>定义线程的执行顺序：通过操作变量，来控制线程执行的步骤
生产场景?*
点餐扫码–>弹出菜单–>选菜下单–>弹出清单类目–>吃完结账–>弹出结果
类似的生产线中，当每个环节需要不同数量的线程去执行，就可以派上用场了
condition精确唤醒代码
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class TestCondition {
public static void main(String[] args) {
//操作同一个资源类ServiceImpl
ServiceImpl service = new ServiceImpl();
//三个线程每个执行5次
new Thread(() -> {
for (int i = 0; i < 5; i++) {
service.printA();
}
}, "A").start();
new Thread(() -> {
for (int i = 0; i < 5; i++) {
service.printB();
}
}, "B").start();
new Thread(() -> {
for (int i = 0; i < 5; i++) {
service.printC();
}
}, "C").start();
}
}
class ServiceImpl {
//仅限本类使用，因此使用private修饰
private Lock lock = new ReentrantLock();//锁
private Condition conditionA = lock.newCondition();//同步监视器
private Condition conditionB = lock.newCondition();//同步监视器
private Condition conditionC = lock.newCondition();//同步监视器
private int flag = 1;//判断执行谁的变量，同时也是判断谁先执行，不使用此变量就会随机一个线程开始，然后有序执行
public void printA() {
lock.lock();//同一把锁，因此不可能同时进入
try {
//业务代码：判断-->执行-->通知
while (flag != 1) {//不用if，if会有虚假唤醒
//等待
conditionA.await();
}
System.out.println(Thread.currentThread().getName() + "===A方法===");
//唤醒等待的指定线程：B
flag = 2;
conditionB.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printB() {
lock.lock();//同一把锁，因此不可能同时进入
try {
//业务代码：判断-->执行-->通知
while (flag != 2) {//不用if，if会有虚假唤醒
//等待
conditionB.await();
}
System.out.println(Thread.currentThread().getName() + "===B方法===");
//唤醒等待的指定线程：C
flag = 3;
conditionC.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printC() {
lock.lock();//同一把锁，因此不可能同时进入
try {
//业务代码：判断-->执行-->通知
while (flag != 3) {//不用if，if会有虚假唤醒
//等待
conditionC.await();
}
System.out.println(Thread.currentThread().getName() + "===C方法===");
//唤醒等待的指定线程：A
flag = 1;
conditionA.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
结果输出
A===A方法=== B===B方法=== C===C方法=== A===A方法=== B===B方法=== C===C方法=== A===A方法=== B===B方法=== C===C方法=== A===A方法=== B===B方法=== C===C方法=== A===A方法=== B===B方法=== C===C方法===
