LeetCode 1114. Print in Orderjavaweixin40037938的博客-

Description：
Suppose we have a class:
public class Foo {
public void first() { print(“first”); }
public void second() { print(“second”); }
public void third() { print(“third”); }
}
The same instance of Foo will be passed to three different threads. Thread A will call first(), thread B will call second(), and thread C will call third(). Design a mechanism and modify the program to ensure that second() is executed after first(), and third() is executed after second().

Solution:
解法一：
使用CountDownLatch，当一个线程开始加了await()方法，当CountDownLatch没有变成0的时候，是无法执行的。所以下例只会按照123的顺序执行。

import java.util.concurrent.CountDownLatch; class Foo { private final CountDownLatch l2; private final CountDownLatch l3; public Foo() {         l2 = new CountDownLatch(1);         l3 = new CountDownLatch(1); } public void first(Runnable printFirst) throws InterruptedException {         printFirst.run();         l2.countDown(); } public void second(Runnable printSecond) throws InterruptedException {         l2.await();         printSecond.run();         l3.countDown(); } public void third(Runnable printThird) throws InterruptedException {         l3.await();         printThird.run(); } } 

解法二：
使用Semaphore

import java.util.concurrent.CountDownLatch; class Foo {          Semaphore run2, run3; public Foo() {         run2 = new Semaphore(0);         run3 = new Semaphore(0); } public void first(Runnable printFirst) throws InterruptedException {         printFirst.run();         run2.release; } public void second(Runnable printSecond) throws InterruptedException {         run2.acquire();         printSecond.run();         run3.release; } public void third(Runnable printThird) throws InterruptedException {         run3.acquire();         printThird.run(); } } 

解法三：
可以手动写一个类似于方法一和方法二的版本：
设置两个布尔变量，如果不允许线程跑，则一直等待，调用了wait()方法的线程会处于等待池中。notifyAll()唤醒所有线程，把所有等待池的线程放入锁池，锁池中的线程竞争。
对于 volatile 的理解，可以看这里
volatile 保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。

每个线程在运行过程中都有自己的工作内存，那么线程1在运行的时候，会将stop变量的值拷贝一份放在自己的工作内存当中。
那么当线程2更改了stop变量的值之后，但是还没来得及写入主存当中，线程2转去做其他事情了，那么线程1由于不知道线程2对stop变量的更改，因此还会一直循环下去。
但是用volatile修饰之后就变得不一样了：
第一：使用volatile关键字会强制将修改的值立即写入主存；
第二：使用volatile关键字的话，当线程2进行修改时，会导致线程1的工作内存中缓存变量stop的缓存行无效（反映到硬件层的话，就是CPU的L1或者L2缓存中对应的缓存行无效）；
第三：由于线程1的工作内存中缓存变量stop的缓存行无效，所以线程1再次读取变量stop的值时会去主存读取。
那么在线程2修改stop值时（当然这里包括2个操作，修改线程2工作内存中的值，然后将修改后的值写入内存），会使得线程1的工作内存中缓存变量stop的缓存行无效，然后线程1读取时，发现自己的缓存行无效，它会等待缓存行对应的主存地址被更新之后，然后去对应的主存读取最新的值。
那么线程1读取到的就是最新的正确的值。

class Foo { private volatile boolean onePrinted; private volatile boolean twoPrinted; public Foo() {         onePrinted = false;         twoPrinted = false; } public synchronized void first(Runnable printFirst) throws InterruptedException {         printFirst.run();         onePrinted = true; notifyAll(); } public synchronized void second(Runnable printSecond) throws InterruptedException { while(!onePrinted) { wait(); }         printSecond.run();         twoPrinted = true; notifyAll(); } public synchronized void third(Runnable printThird) throws InterruptedException { while(!twoPrinted) { wait(); }         printThird.run(); } } 

参考 / Reference：https://www.cnblogs.com/dolphin0520/p/3920373.html