并发编程中，我们可能会遇到这样一个场景
A、B两个线程并行，但是我希望保证B线程在A线程执行完了后再执行
这个时候就需要线程间进行通讯
A执行完了后对B说一声，喂B，我执行完了
来康康用Java怎么实现
1、基于synchronized
2、基于reentrantLock
3、基于volatile
4、基于countDownLatch
我目前就知道这四种
wait() 和 notify()都是Object类的通讯方法，注意一点，wait和 notify必须搭配synchronized使用，并且wait()会释放锁，notify()不会释放锁
public class SynchronizedTest {
//定义个year，用来记录某明星的练习年数
private static double year;
public void run() {
//线程A，练习唱跳rap
Thread threadA = new Thread(() -> {
synchronized (this) {
for (year = 0.5; year <= 5; year += 0.5) {
System.out.println("蔡徐鸡开始练习唱跳rap：已练习" + year + "年");
try {
Thread.sleep(288);
} catch (InterruptedException e) {
e.printStackTrace();
}
//众所周知，练习两年半即可出道
if (year == 2.5) {
System.out.println("===========================>成功练习两年半，出道！！！");
this.notify();
}
}
}
});
//线程B，练习打篮球
Thread threadB = new Thread(() -> {
while (true) {
synchronized (this) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("蔡徐鸡开始练习打篮球");
}
}
});
//注意，一定要先启动B，不然会导致B永远拿不到锁
threadB.start();
threadA.start();
}
public static void main(String[] args) {
SynchronizedTest test = new SynchronizedTest();
test.run();
}
}
运行结果：
蔡徐鸡开始练习唱跳rap：已练习0.5年
蔡徐鸡开始练习唱跳rap：已练习1.0年
蔡徐鸡开始练习唱跳rap：已练习1.5年
蔡徐鸡开始练习唱跳rap：已练习2.0年
蔡徐鸡开始练习唱跳rap：已练习2.5年
===========================>成功练习两年半，出道！！！
蔡徐鸡开始练习唱跳rap：已练习3.0年
蔡徐鸡开始练习唱跳rap：已练习3.5年
蔡徐鸡开始练习唱跳rap：已练习4.0年
蔡徐鸡开始练习唱跳rap：已练习4.5年
蔡徐鸡开始练习唱跳rap：已练习5.0年
蔡徐鸡开始练习打篮球
注意看运行结果，线程A在执行notify后并没有释放锁，而是执行完当前任务才开始执行线程B的任务
ReentrantLock也能实现线程间通讯，不过有点麻烦，需要结合ReentrantLock的Condition
public class LockTest {
//定义个year，用来记录某明星练习打篮球的年数
private static double year;
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();
//线程A，练习唱跳rap
Thread threadA = new Thread(() -> {
//执行业务代码前上锁
lock.lock();
for (year = 0.5; year <= 5; year += 0.5) {
System.out.println("蔡徐鸡开始练习唱跳rap：已练习" + year + "年");
try {
Thread.sleep(288);
} catch (InterruptedException e) {
e.printStackTrace();
}
//众所周知，练习两年半即可出道
if (year == 2.5) {
System.out.println("===========================>成功练习两年半，出道！！！");
//唤醒等待中的线程
condition.signal();
}
}
//业务代码执行完后解锁
lock.unlock();
});
//线程B，练习打篮球
Thread threadB = new Thread(() -> {
//执行业务代码前上锁
lock.lock();
while (true) {
try {
//让线程等待，如果计数器为0的话，则立即执行
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("蔡徐老母鸡开始练习打篮球");
break;
}
//业务代码执行完后解锁
lock.unlock();
});
//注意，一定要先启动B，不然会导致B永远拿不到锁
threadB.start();
threadA.start();
}
}
运行结果：
蔡徐鸡开始练习唱跳rap：已练习0.5年
蔡徐鸡开始练习唱跳rap：已练习1.0年
蔡徐鸡开始练习唱跳rap：已练习1.5年
蔡徐鸡开始练习唱跳rap：已练习2.0年
蔡徐鸡开始练习唱跳rap：已练习2.5年
===========================>成功练习两年半，出道！！！
蔡徐鸡开始练习唱跳rap：已练习3.0年
蔡徐鸡开始练习唱跳rap：已练习3.5年
蔡徐鸡开始练习唱跳rap：已练习4.0年
蔡徐鸡开始练习唱跳rap：已练习4.5年
蔡徐鸡开始练习唱跳rap：已练习5.0年
蔡徐老母鸡开始练习打篮球
效果和synchronized+wait() 和 notify()一样一样的
使用共享变量也能实现，用volatile即可，原理就是多个线程共同监听同个变量，根据变量的值变化来执行对应的任务，此处volatile的作用就是让其它线程能即时感知变量值的改变
public class volatileTest {
//定义一个共享变量，注意，必须用volatile修饰
static volatile boolean flag = false;
//定义个year，用来记录某明星练习打篮球的年数
private static double year;
public static void main(String[] args) {
//线程A，练习唱跳rap
Thread threadA = new Thread(() -> {
while (true) {
if (!flag) {
for (year = 0.5; year <= 5; year += 0.5) {
System.out.println("蔡徐鸡开始练习唱跳rap：已练习" + year + "年");
try {
Thread.sleep(288);
} catch (InterruptedException e) {
e.printStackTrace();
}
//众所周知，练习两年半即可出道
if (year == 2.5) {
System.out.println("===========================>成功练习两年半，出道！！！");
year = 0.5;
flag = true;
break;
}
}
}
}
});
//线程B，练习打篮球
Thread threadB = new Thread(() -> {
while (true) {
if (flag) {
System.out.println("蔡徐老母鸡开始练习打篮球");
break;
}
}
});
// 启动线程
threadA.start();
threadB.start();
}
}
运行结果：
蔡徐鸡开始练习唱跳rap：已练习0.5年
蔡徐鸡开始练习唱跳rap：已练习1.0年
蔡徐鸡开始练习唱跳rap：已练习1.5年
蔡徐鸡开始练习唱跳rap：已练习2.0年
蔡徐鸡开始练习唱跳rap：已练习2.5年
===========================>成功练习两年半，出道！！！
蔡徐老母鸡开始练习打篮球
CountDownLatch是JUC包下的一个并发编程工具，主要有两个方法，countDown和await，CountDownLatch底层维护了一个计数器，在实例化的时候设置，当调用countDown方法时，计数器减一，如果计数器在减一前已经为0，那么什么都不会发生，如果减一后变成0，则唤醒所有等待的线程；await方法会使当前线程等待，直到计数器为0
public class CountDownLatchTest {
//定义个year，用来记录某明星练习打篮球的年数
private static double year;
public static void main(String[] args) {
CountDownLatch latch = new CountDownLatch(1);
//线程A，练习唱跳rap
Thread threadA = new Thread(() -> {
for (year = 0.5; year <= 5; year += 0.5) {
System.out.println("蔡徐鸡开始练习唱跳rap：已练习" + year + "年");
try {
Thread.sleep(288);
} catch (InterruptedException e) {
e.printStackTrace();
}
//众所周知，练习两年半即可出道
if (year == 2.5) {
System.out.println("===========================>成功练习两年半，出道！！！");
//计数器减一
latch.countDown();
}
}
});
//线程B，练习打篮球
Thread threadB = new Thread(() -> {
while (true) {
try {
//让线程等待，如果计数器为0的话，则立即执行
latch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("蔡徐老母鸡开始练习打篮球");
break;
}
});
// 启动线程
threadA.start();
threadB.start();
}
}
运行结果：
蔡徐鸡开始练习唱跳rap：已练习0.5年
蔡徐鸡开始练习唱跳rap：已练习1.0年
蔡徐鸡开始练习唱跳rap：已练习1.5年
蔡徐鸡开始练习唱跳rap：已练习2.0年
蔡徐鸡开始练习唱跳rap：已练习2.5年
===========================>成功练习两年半，出道！！！
蔡徐鸡开始练习唱跳rap：已练习3.0年
蔡徐老母鸡开始练习打篮球
蔡徐鸡开始练习唱跳rap：已练习3.5年
蔡徐鸡开始练习唱跳rap：已练习4.0年
蔡徐鸡开始练习唱跳rap：已练习4.5年
蔡徐鸡开始练习唱跳rap：已练习5.0年
如果你多运行几次，你会发现线程B执行的时机是随机的，但永远在计数器为0后才开始执行，也就是说计数器为0后，线程A和线程B谁抢到锁就谁执行
文中所有demo都是复制即可运行，大家还是要多动手，家里有条件的都用idea跑一跑，没条件的可以用手抄
