Java多线程 之 lock与condition的使用（十四）

在博文 Java多线程 之 wait、notifyAll（十二） 中使用wait、notify使“打蜡”和“抛光”两个任务能够协同工作，本文阐述使用lock、condition来实现。而且使用signalAll要比使用notifyAll更安全。

1.使用抛出异常

package org.fan.learn.thread.testCondition;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
/**
* Created by fan on 2016/7/4.
*/
class Car {
private ReentrantLock reentrantLock = new ReentrantLock();
private Condition condition = reentrantLock.newCondition();
private boolean waxOn = false;
//同步方法
//打蜡
void waxing() {
reentrantLock.lock();
try {
waxOn = true;
condition.signalAll();
} finally {
reentrantLock.unlock();
}
}
//同步方法
//抛光
void buffing() {
reentrantLock.lock();
try {
waxOn = false;
condition.signalAll();
} finally {
reentrantLock.unlock();
}
}
//同步方法
//等待打蜡完成
void waitForWaxing() throws InterruptedException {
reentrantLock.lock();
try {
while (!waxOn) {
condition.await();
}
} finally {
reentrantLock.unlock();
}
}
//同步方法
//等待抛光完成
void waitForBuffing() throws InterruptedException {
reentrantLock.lock();
try {
while (waxOn) {
condition.await();
}
}  finally {
reentrantLock.unlock();
}
}
}
//打蜡任务
//一次打蜡完成，需要等待抛光完成之后才能继续打蜡
class WaxingTask implements Runnable {
private Car car;
public WaxingTask(Car car) {
this.car = car;
}
public void run() {
try {
while (!Thread.interrupted()) {
System.out.println("waxing");
TimeUnit.MILLISECONDS.sleep(200);
car.waxing();
car.waitForBuffing();
}
} catch (InterruptedException e) {
//打印异常堆栈
e.printStackTrace();
}
System.out.println("Ending Waxing Task");
}
}
//抛光任务
//在抛光之前必须要先打蜡，需要等待打蜡完成才能抛光
class BuffingTask implements Runnable {
private Car car;
public BuffingTask(Car car) {
this.car = car;
}
public void run() {
try {
while (!Thread.interrupted()) {
car.waitForWaxing();
System.out.println("Buffing");
TimeUnit.MILLISECONDS.sleep(200);
car.buffing();
}
} catch (InterruptedException e) {
//打印异常堆栈
e.printStackTrace();
}
System.out.println("Ending Buffering Task");
}
}
public class WaxingBuffing {
public static void main(String[] args) throws InterruptedException {
Car car = new Car();
ExecutorService exe = Executors.newCachedThreadPool();
exe.execute(new WaxingTask(car));
exe.execute(new BuffingTask(car));
TimeUnit.SECONDS.sleep(5);
//向所有任务发送interrupt()信号
exe.shutdownNow();
System.out.println("main exit");
}
}

使用抛出异常的输出：

waxing
Buffing
waxing
Buffing
waxing
Buffing
waxing
Buffing
waxing
main exit
Ending Waxing Task
java.lang.InterruptedException: sleep interrupted
Ending Buffering Task
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 org.fan.learn.thread.testCondition.WaxingTask.run(WaxingBuffing.java:110)
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
at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.reportInterruptAfterWait(AbstractQueuedSynchronizer.java:2014)
at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2048)
at org.fan.learn.thread.testCondition.Car.waitForWaxing(WaxingBuffing.java:49)
at org.fan.learn.thread.testCondition.BuffingTask.run(WaxingBuffing.java:134)
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)

Process finished with exit code 0

2.使用catch异常：

package org.fan.learn.thread.testCondition;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
/**
* Created by fan on 2016/7/4.
*/
class Car {
private ReentrantLock reentrantLock = new ReentrantLock();
private Condition condition = reentrantLock.newCondition();
private boolean waxOn = false;
//同步方法
//打蜡
void waxing() {
reentrantLock.lock();
try {
waxOn = true;
condition.signalAll();
} finally {
reentrantLock.unlock();
}
}
//同步方法
//抛光
void buffing() {
reentrantLock.lock();
try {
waxOn = false;
condition.signalAll();
} finally {
reentrantLock.unlock();
}
}
//同步方法
//等待打蜡完成
void waitForWaxing() {
reentrantLock.lock();
try {
while (!waxOn) {
condition.await();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
reentrantLock.unlock();
}
}
//同步方法
//等待抛光完成
void waitForBuffing()  {
reentrantLock.lock();
try {
while (waxOn) {
condition.await();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
reentrantLock.unlock();
}
}
}
//打蜡任务
//一次打蜡完成，需要等待抛光完成之后才能继续打蜡
class WaxingTask implements Runnable {
private Car car;
public WaxingTask(Car car) {
this.car = car;
}
public void run() {
try {
while (!Thread.interrupted()) {
System.out.println("waxing");
TimeUnit.MILLISECONDS.sleep(200);
car.waxing();
car.waitForBuffing();
}
} catch (InterruptedException e) {
//打印异常堆栈
e.printStackTrace();
}
System.out.println("Ending Waxing Task");
}
}
//抛光任务
//在抛光之前必须要先打蜡，需要等待打蜡完成才能抛光
class BuffingTask implements Runnable {
private Car car;
public BuffingTask(Car car) {
this.car = car;
}
public void run() {
try {
while (!Thread.interrupted()) {
car.waitForWaxing();
System.out.println("Buffing");
TimeUnit.MILLISECONDS.sleep(200);
car.buffing();
}
} catch (InterruptedException e) {
//打印异常堆栈
e.printStackTrace();
}
System.out.println("Ending Buffering Task");
}
}
public class WaxingBuffing {
public static void main(String[] args) throws InterruptedException {
Car car = new Car();
ExecutorService exe = Executors.newCachedThreadPool();
exe.execute(new WaxingTask(car));
exe.execute(new BuffingTask(car));
TimeUnit.SECONDS.sleep(5);
//向所有任务发送interrupt()信号
exe.shutdownNow();
System.out.println("main exit");
}
}

这个无法正常结束。。

在waitForWaxing中catch异常之后，无法继续执行了。因此需要往外抛。

对于异常：如果一个方法A中捕获异常，调用该方法Ａ的方法Ｂ则无法正常退出，需要Ａ方法抛出异常，由方法Ｂ捕获，这时执行完catch之后可以继续执行方法Ｂ中的语句。

使用catch异常的输出：

waxing
Buffing
waxing
Buffing
waxing
main exit
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 org.fan.learn.thread.testCondition.WaxingTask.run(WaxingBuffing.java:110)
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
at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.reportInterruptAfterWait(AbstractQueuedSynchronizer.java:2014)
at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2048)
at org.fan.learn.thread.testCondition.Car.waitForWaxing(WaxingBuffing.java:61)
at org.fan.learn.thread.testCondition.BuffingTask.run(WaxingBuffing.java:134)
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)
Ending Waxing Task
Buffing