本案例描述的是，给一辆汽车打蜡、抛光的场景。
Car 是一辆被打蜡抛光的汽车，扮演共享资源的角色。
WaxOnCommand 负责给汽车打蜡，打蜡时需要独占整部车，一次打一部分蜡，等待抛光，然后再打一部分蜡。
BuffCommand 负责给汽车抛光，抛光时需要独占整部车，每一次会将刚打上的蜡抛光，然后等待打蜡，然后再将刚打上的蜡抛光。
WaxOnCommand 、BuffCommand 分别由两个线程相互交替地执行：
WaxOnCommand 打蜡、等待抛光，BuffCommand 抛光，等待打蜡；
WaxOnCommand 打蜡、等待抛光，BuffCommand 抛光，等待打蜡；
WaxOnCommand 打蜡、等待抛光，BuffCommand 抛光，等待打蜡；
......
CarWaxBuffDemo 演示这个场景。
下面是类之间的关系图。
由于 ExecutorServices 的使用和 Command Pattern 很相似，所以参照其 UML 绘制而成。
代码实现：
Car, 可以改变汽车的打蜡状态，可以等待打蜡状态的改变。输出内容到控制台时，会把当前执行线程一一同输出。
public class Car {
private boolean isWaxed = false;
public synchronized void waxed(){
isWaxed = true;
print(" car is waxed now ");
notifyAll();
}
public synchronized void unwaxed(){
isWaxed = false;
print(" car is unwaxed now ");
notifyAll();
}public synchronized void waitingForReWax() throws InterruptedException{
while (isWaxed == true){
wait();
}
print(" OK to re-wax ");
}
public synchronized void waitingForReBuff() throws InterruptedException{
while (isWaxed == false){
wait();
}
print(" OK to re-Buff ");
}
public void print(String msg){
System.out.println("[" + Thread.currentThread().getName() + " ] " + msg);
}
}
WaxonComman，给汽车打蜡，主要是两个动作：1.等待可以打蜡，2.打蜡。
import java.util.concurrent.TimeUnit;
public class WaxonCommand implements Runnable {
private Car car;
public WaxonCommand(Car car){
this.car = car;
}
@Override
public void run() {
try {
while (true){
car.waitingForReWax();
print(" WaxOn take action ");
TimeUnit.MILLISECONDS.sleep();
car.waxed();
}
}catch (Exception e) {
e.printStackTrace();
}
try {
TimeUnit.MILLISECONDS.sleep();
} catch (InterruptedException e) {
e.printStackTrace();
}
print(" Ending WaxOn action ");
}
public void print(String msg){
System.out.println("[" + Thread.currentThread().getName() + " ] " + msg);
}
}
buffCommand, 给汽车抛光，主要两个动作：1.等待可以抛光，2. 抛光。
import java.util.concurrent.TimeUnit;
public class BuffCommand implements Runnable{
private Car car;
public BuffCommand(Car car){
this.car = car;
}
@Override
public void run() {
try {
while (true){
car.waitingForReBuff();
print(" Buff take action ");
TimeUnit.MILLISECONDS.sleep();
car.unwaxed();
}
}catch (InterruptedException e) {
e.printStackTrace();
}
try {
TimeUnit.MILLISECONDS.sleep();
} catch (InterruptedException e) {
e.printStackTrace();
}
print(" Ending Buff action ");
}
public void print(String msg){
System.out.println("[" + Thread.currentThread().getName() + " ] " + msg);
}
}
演示给汽车交替打蜡、抛光的场景。给 1 秒的时间，让 WaxonCommand / BuffComand 线程进行打蜡、抛光操作，1 秒后，中断他们的操作。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit; public class CarWaxBuffDemo { public static void main() throws InterruptedException{
ExecutorService exec = Executors.newCachedThreadPool(); Car car = new Car();
exec.execute(new BuffCommand(car));
exec.execute(new WaxonCommand(car)); TimeUnit.SECONDS.sleep(1);
System.out.println(" executor stopping ");
exec.shutdownNow();
}
}
输出结果：
在被强制中断前，thread-1 和 thread-2 交替进行打蜡、抛光操作。
[pool-1-thread-1 ] OK to re-wax
[pool-1-thread-1 ] WaxOn take action
[pool-1-thread-1 ] car is waxed now
[pool-1-thread-2 ] OK to re-Buff
[pool-1-thread-2 ] Buff take action
[pool-1-thread-2 ] car is unwaxed now
[pool-1-thread-1 ] OK to re-wax
[pool-1-thread-1 ] WaxOn take action
[pool-1-thread-1 ] car is waxed now
[pool-1-thread-2 ] OK to re-Buff
[pool-1-thread-2 ] Buff take action
[pool-1-thread-2 ] car is unwaxed now
[pool-1-thread-1 ] OK to re-wax
[pool-1-thread-1 ] WaxOn take action
[pool-1-thread-1 ] car is waxed now
[pool-1-thread-2 ] OK to re-Buff
[pool-1-thread-2 ] Buff take action
[pool-1-thread-2 ] car is unwaxed now
[pool-1-thread-1 ] OK to re-wax
[pool-1-thread-1 ] WaxOn take action
[pool-1-thread-1 ] car is waxed now
[pool-1-thread-2 ] OK to re-Buff
[pool-1-thread-2 ] Buff take action
[pool-1-thread-2 ] car is unwaxed now
[pool-1-thread-1 ] OK to re-wax
[pool-1-thread-1 ] WaxOn take action
[pool-1-thread-1 ] car is waxed now
[pool-1-thread-2 ] OK to re-Buff
[pool-1-thread-2 ] Buff take action
[pool-1-thread-2 ] car is unwaxed now
[pool-1-thread-1 ] OK to re-wax
[pool-1-thread-1 ] WaxOn take action
executor stopping
java.lang.InterruptedException
at java.lang.Object.wait(Native Method)
at java.lang.Object.wait(Object.java:502)
at concurrencyCooperation.Car.waitingForReBuff(Car.java:29)
at concurrencyCooperation.BuffCommand.run(BuffCommand.java:17)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
at java.lang.Thread.run(Thread.java:745)
java.lang.InterruptedException: sleep interrupted
at java.lang.Thread.sleep(Native Method)
at java.lang.Thread.sleep(Thread.java:340)
at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
at concurrencyCooperation.WaxonCommand.run(WaxonCommand.java:20)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
at java.lang.Thread.run(Thread.java:745)
[pool-1-thread-2 ] Ending Buff action
[pool-1-thread-1 ] Ending WaxOn action
参考资料 ：
Page 857, wait() and notifyAll(), Thinking in Java