前文从任务到线程:Java结构化并发应用程序中介绍了如何安排任务启动线程。
线程在启动之后,正常的情况下会运行到任务完成,但是有的情况下会需要提前结束任务,如用户取消操作等。可是,让线程安全、快速和可靠地停止并不是件容易的事情,因为Java中没有提供安全的机制来终止线程。虽然有Thread.stop/suspend等方法,但是这些方法存在缺陷,不能保证线程中共享数据的一致性,所以应该避免直接调用。
线程在终止的过程中,应该先进行操作来清除当前的任务,保持共享数据的一致性,然后再停止。
庆幸的是,Java中提供了中断机制,来让多线程之间相互协作,由一个进程来安全地终止另一个进程。
1. 任务的取消
如果外部的代码能在某个操作正常完成之前将其设置为完成状态,则该操作为可取消的(Cancellable)。
操作被取消的原因有很多,比如超时,异常,请求被取消等等。
一个可取消的任务要求必须设置取消策略,即如何取消,何时检查取消命令,以及接收到取消命令之后如何处理。
最简单的取消办法就是利用取消标志位,如下所示:
public class PrimeGenerator implements Runnable {
private static ExecutorService exec = Executors.newCachedThreadPool();
private final List primes
= new ArrayList();
//取消标志位
private volatile boolean cancelled;
public void run() {
BigInteger p = BigInteger.ONE;
//每次在生成下一个素数时坚持是否取消
//如果取消,则退出
while (!cancelled) {
p = p.nextProbablePrime();
synchronized (this) {
primes.add(p);
}
}
}
public void cancel() {
cancelled = true;
}
public synchronized List get() {
return new ArrayList(primes);
}
static List aSecondOfPrimes() throws InterruptedException {
PrimeGenerator generator = new PrimeGenerator();
exec.execute(generator);
try {
SECONDS.sleep(1);
} finally {
generator.cancel();
}
return generator.get();
}
}
这段代码用于生成素数,并在任务运行一秒钟之后终止。其取消策略为:通过改变取消标志位取消任务,任务在每次生成下一随机素数之前检查任务是否被取消,被取消后任务将退出。
然而,该机制的最大的问题就是无法应用于拥塞方法。假设在循环中调用了拥塞方法,任务可能因拥塞而永远不会去检查取消标志位,甚至会造成永远不能停止。
1.1 中断
为了解决拥塞方法带来的问题,就需要使用中断机制来取消任务。
虽然在Java规范中,线程的取消和中断没有必然联系,但是在实践中发现:中断是取消线程的最合理的方式。
Thread类中和中断相关的方法如下:
public class Thread {
// 中断当前线程
public void interrupt();
// 判断当前线程是否被中断
public boolen isInterrupt();
// 清除当前线程的中断状态,并返回之前的值
public static boolen interrupt();
}
调用Interrupt方法并不是意味着要立刻停止目标线程,而只是传递请求中断的消息。所以对于中断操作的正确理解为:正在运行的线程收到中断请求之后,在下一个合适的时刻中断自己。
使用中断方法改进素数生成类如下:
public class PrimeProducer extends Thread {
private final BlockingQueue queue;
PrimeProducer(BlockingQueue queue) {
this.queue = queue;
}
public void run() {
try {
BigInteger p = BigInteger.ONE;
//使用中断的方式来取消任务
while (!Thread.currentThread().isInterrupted())
//put方法会隐式检查并响应中断
queue.put(p = p.nextProbablePrime());
} catch (InterruptedException consumed) {
/* 允许任务退出 */
}
}
public void cancel() {
interrupt();
}
}
代码中有两次检查中断请求:
第一次是在循环开始前,显示检查中断请求;
第二次是在put方法,该方法为拥塞的,会隐式坚持当前线程是否被中断;
1.2 中断策略
和取消策略类似,可以被中断的任务也需要有中断策略:
即如何中断,合适检查中断请求,以及接收到中断请求之后如何处理。
由于每个线程拥有各自的中断策略,因此除非清楚中断对目标线程的含义,否者不要中断该线程。
正是由于以上原因,大多数拥塞的库函数在检测到中断都是抛出中断异常(InterruptedException)作为中断响应,让线程的所有者去处理,而不是去真的中断当前线程。
虽然有人质疑Java没有提供抢占式的中断机制,但是开发人员通过处理中断异常的方法,可以定制更为灵活的中断策略,从而在响应性和健壮性之间做出合理的平衡。
一般情况的中断响应方法为:
传递异常:收到中断异常之后,直接将该异常抛出;
回复中断状态:即再次调用Interrupt方法,恢复中断状态,让调用堆栈的上层能看到中断状态进而处理它。
切记,只有实现了线程中断策略的代码才能屏蔽中断请求,在常规的任务和库代码中都不应该屏蔽中断请求。中断请求是线程中断和取消的基础。
1.3 定时运行
定时运行一个任务是很常见的场景,很多问题是很费时间的,就需在规定时间内完成,如果没有完成则取消任务。
以下代码就是一个定时执行任务的实例:
public class TimedRun1 {
private static final ScheduledExecutorService cancelExec = Executors.newScheduledThreadPool(1);
public static void timedRun(Runnable r,
long timeout, TimeUnit unit) {
final Thread taskThread = Thread.currentThread();
cancelExec.schedule(new Runnable() {
public void run() {
// 中断线程,
// 违规,不能在不知道中断策略的前提下调用中断,
// 该方法可能被任意线程调用。
taskThread.interrupt();
}
}, timeout, unit);
r.run();
}
}
很可惜,这是反面的例子,因为timedRun方法在不知道Runnable对象的中断策略的情况下,就中断该任务,这样会承担很大的风险。而且如果Runnable对象不支持中断, 则该定时模型就会失效。
为了解决上述问题,就需要执行任务都线程有自己的中断策略,如下:
public class LaunderThrowable {
public static RuntimeException launderThrowable(Throwable t) {
if (t instanceof RuntimeException)
return (RuntimeException) t;
else if (t instanceof Error)
throw (Error) t;
else
throw new IllegalStateException("Not unchecked", t);
}
}
public class TimedRun2 {
private static final ScheduledExecutorService cancelExec = newScheduledThreadPool(1);
public static void timedRun(final Runnable r,
long timeout, TimeUnit unit)
throws InterruptedException {
class RethrowableTask implements Runnable {
private volatile Throwable t;
public void run() {
try {
r.run();
} catch (Throwable t) {
//中断策略,保存当前抛出的异常,退出
this.t = t;
}
}
// 再次抛出异常
void rethrow() {
if (t != null)
throw launderThrowable(t);
}
}
RethrowableTask task = new RethrowableTask();
final Thread taskThread = new Thread(task);
//开启任务子线程
taskThread.start();
//定时中断任务子线程
cancelExec.schedule(new Runnable() {
public void run() {
taskThread.interrupt();
}
}, timeout, unit);
//限时等待任务子线程执行完毕
taskThread.join(unit.toMillis(timeout));
//尝试抛出task在执行中抛出到异常
task.rethrow();
}
}
无论Runnable对象是否支持中断,RethrowableTask对象都会记录下来发生的异常信息并结束任务,并将该异常再次抛出。
1.4 通过Future取消任务
Future用来管理任务的生命周期,自然也可以来取消任务,调用Future.cancel方法就是用中断请求结束任务并退出,这也是Executor的默认中断策略。
用Future实现定时任务的代码如下:
public class TimedRun {
private static final ExecutorService taskExec = Executors.newCachedThreadPool();
public static void timedRun(Runnable r,
long timeout, TimeUnit unit)
throws InterruptedException {
Future> task = taskExec.submit(r);
try {
task.get(timeout, unit);
} catch (TimeoutException e) {
// 因超时而取消任务
} catch (ExecutionException e) {
// 任务异常,重新抛出异常信息
throw launderThrowable(e.getCause());
} finally {
// 如果该任务已经完成,将没有影响
// 如果任务正在运行,将因为中断而被取消
task.cancel(true); // interrupt if running
}
}
}
1.5 不可中断的拥塞
一些的方法的拥塞是不能响应中断请求的,这类操作以I/O操作居多,但是可以让其抛出类似的异常,来停止任务:
Socket I/O: 关闭底层socket,所有因执行读写操作而拥塞的线程会抛出SocketException;
同步 I/O:大部分Channel都实现了InterruptiableChannel接口,可以响应中断请求,抛出异常ClosedByInterruptException;
Selector的异步 I/O:Selector执行select方法之后,再执行close和wakeUp方法就会抛出异常ClosedSelectorException。
以套接字为例,其利用关闭socket对象来响应异常的实例如下:
public class ReaderThread extends Thread {
private static final int BUFSZ = 512;
private final Socket socket;
private final InputStream in;
public ReaderThread(Socket socket) throws IOException {
this.socket = socket;
this.in = socket.getInputStream();
}
public void interrupt() {
try {
// 关闭套接字
// 此时in.read会抛出异常
socket.close();
} catch (IOException ignored) {
} finally {
// 正常的中断
super.interrupt();
}
}
public void run() {
try {
byte[] buf = new byte[BUFSZ];
while (true) {
int count = in.read(buf);
if (count < 0)
break;
else if (count > 0)
processBuffer(buf, count);
}
} catch (IOException e) {
// 如果socket关闭,in.read方法将会抛出异常
// 借此机会,响应中断,线程退出
}
}
public void processBuffer(byte[] buf, int count) {
}
}
2. 停止基于线程的服务
一个应用程序是由多个服务构成的,而每个服务会拥有多个线程为其工作。当应用程序关闭服务时,由服务来关闭其所拥有的线程。服务为了便于管理自己所拥有的线程,应该提供生命周期方来关闭这些线程。对于ExecutorService,其包含线程池,是其下属线程的拥有者,所提供的生命周期方法就是shutdown和shutdownNow方法。
如果服务的生命周期大于所创建线程的生命周期,服务就应该提供生命周期方法来管理线程。
2.1 强行关闭和平缓关闭
我们以日志服务为例,来说明两种关闭方式的不同。首先,如下代码是不支持关闭的日志服务,其采用多生产者-单消费者模式,生产者将日志消息放入拥塞队列中,消费者从队列中取出日志打印出来。
public class LogWriter {
// 拥塞队列作为缓存区
private final BlockingQueue queue;
// 日志线程
private final LoggerThread logger;
// 队列大小
private static final int CAPACITY = 1000;
public LogWriter(Writer writer) {
this.queue = new LinkedBlockingQueue(CAPACITY);
this.logger = new LoggerThread(writer);
}
public void start() {
logger.start();
}
public void log(String msg) throws InterruptedException {
queue.put(msg);
}
private class LoggerThread extends Thread {
//线程安全的字节流
private final PrintWriter writer;
public LoggerThread(Writer writer) {
this.writer = new PrintWriter(writer, true); // autoflush
}
public void run() {
try {
while (true)
writer.println(queue.take());
} catch (InterruptedException ignored) {
} finally {
writer.close();
}
}
}
}
如果没有终止操作,以上任务将无法停止,从而使得JVM也无法正常退出。但是,让以上的日志服务停下来其实并非难事,因为拥塞队列的take方法支持响应中断,这样直接关闭服务的方法就是强行关闭,强行关闭的方式不会去处理已经提交但还未开始执行的任务。
但是,关闭日志服务前,拥塞队列中可能还有没有及时打印出来的日志消息,所以强行关闭日志服务并不合适,需要等队列中已经存在的消息都打印完毕之后再停止,这就是平缓关闭,也就是在关闭服务时会等待已提交任务全部执行完毕之后再退出。
除此之外,在取消生产者-消费者操作时,还需要同时告知消费者和生产者相关操作已经被取消。
平缓关闭的日志服务如下,其采用了类似信号量的方式记录队列中尚未处理的消息数量。
public class LogService {
private final BlockingQueue queue;
private final LoggerThread loggerThread;
private final PrintWriter writer;
@GuardedBy("this") private boolean isShutdown;
// 信号量 用来记录队列中消息的个数
@GuardedBy("this") private int reservations;
public LogService(Writer writer) {
this.queue = new LinkedBlockingQueue();
this.loggerThread = new LoggerThread();
this.writer = new PrintWriter(writer);
}
public void start() {
loggerThread.start();
}
public void stop() {
synchronized (this) {
isShutdown = true;
}
loggerThread.interrupt();
}
public void log(String msg) throws InterruptedException {
synchronized (this) {
//同步方法判断是否关闭和修改信息量
if (isShutdown) // 如果已关闭,则不再允许生产者将消息添加到队列,会抛出异常
throw new IllegalStateException(/*...*/);
//如果在工作状态,信号量增加
++reservations;
}
// 消息入队列;
queue.put(msg);
}
private class LoggerThread extends Thread {
public void run() {
try {
while (true) {
try {
//同步方法读取关闭状态和信息量
synchronized (LogService.this) {
//如果进程被关闭且队列中已经没有消息了,则消费者退出
if (isShutdown && reservations == 0)
break;
}
// 取出消息
String msg = queue.take();
// 消费消息前,修改信号量
synchronized (LogService.this) {
--reservations;
}
writer.println(msg);
} catch (InterruptedException e) { /* retry */
}
}
} finally {
writer.close();
}
}
}
}
2.2 关闭ExecutorService
在ExecutorService中,其提供了shutdown和shutdownNow方法来分别实现平缓关闭和强制关闭:
shutdownNow:强制关闭,响应速度快,但是会有风险,因为有任务肯执行到一半被终止;
shutdown:平缓关闭,响应速度较慢,会等到全部已提交的任务执行完毕之后再退出,更为安全。
这里还需要说明下shutdownNow方法的局限性,因为强行关闭直接关闭线程,所以无法通过常规的方法获得哪些任务还没有被执行。这就会导致我们无纺知道线程的工作状态,就需要服务自身去记录任务状态。如下为示例代码:
public class TrackingExecutor extends AbstractExecutorService {
private final ExecutorService exec;
//被取消任务的队列
private final Set tasksCancelledAtShutdown =
Collections.synchronizedSet(new HashSet());
public TrackingExecutor(ExecutorService exec) {
this.exec = exec;
}
public void shutdown() {
exec.shutdown();
}
public List shutdownNow() {
return exec.shutdownNow();
}
public boolean isShutdown() {
return exec.isShutdown();
}
public boolean isTerminated() {
return exec.isTerminated();
}
public boolean awaitTermination(long timeout, TimeUnit unit)
throws InterruptedException {
return exec.awaitTermination(timeout, unit);
}
public List getCancelledTasks() {
if (!exec.isTerminated())
throw new IllegalStateException(/*...*/);
return new ArrayList(tasksCancelledAtShutdown);
}
public void execute(final Runnable runnable) {
exec.execute(new Runnable() {
public void run() {
try {
runnable.run();
} finally {
// 如果当前任务被中断且执行器被关闭,则将该任务加入到容器中
if (isShutdown()
&& Thread.currentThread().isInterrupted())
tasksCancelledAtShutdown.add(runnable);
}
}
});
}
}
3. 处理非正常线程终止
导致线程非正常终止的主要原因就是RuntimeException,其表示为不可修复的错误。一旦子线程抛出异常,该异常并不会被父线程捕获,而是会直接抛出到控制台。所以要认真处理线程中的异常,尽量设计完备的try-catch-finally代码块。
当然,异常总是会发生的,为了处理能主动解决未检测异常问题,Thread.API提供了接口UncaughtExceptionHandler。
public interface UncaughtExceptionHandler {
void uncaughtException(Thread t, Throwable e);
}
如果JVM发现一个线程因未捕获异常而退出,就会把该异常交个Thread对象设置的UncaughtExceptionHandler来处理,如果Thread对象没有设置任何异常处理器,那么默认的行为就是上面提到的抛出到控制台,在System.err中输出。
Thread对象通过setUncaughtExceptionHandler方法来设置UncaughtExceptionHandler,比如这样:
public class WitchCaughtThread
{
public static void main(String args[])
{
Thread thread = new Thread(new Task());
thread.setUncaughtExceptionHandler(new ExceptionHandler());
thread.start();
}
}
class ExceptionHandler implements UncaughtExceptionHandler
{
@Override
public void uncaughtException(Thread t, Throwable e)
{
System.out.println("==Exception: "+e.getMessage());
}
}
同样可以为所有的Thread设置一个默认的UncaughtExceptionHandler,通过调用Thread.setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler eh)方法,这是Thread的一个static方法。
下面是一个例子,即发生为捕获异常时将异常写入日志:
public class UEHLogger implements Thread.UncaughtExceptionHandler {
// 将未知的错误计入到日志中
public void uncaughtException(Thread t, Throwable e) {
Logger logger = Logger.getAnonymousLogger();
logger.log(Level.SEVERE, "Thread terminated with exception: " + t.getName(), e);
}
}
在Executor框架中,需要将异常的捕获封装到Runnable或者Callable中并通过execute提交的任务,才能将它抛出的异常交给UncaughtExceptionHandler,而通过submit提交的任务,无论是抛出的未检测异常还是已检查异常,都将被认为是任务返回状态的一部分。如果一个由submit提交的任务由于抛出了异常而结束,那么这个异常将被Future.get封装在ExecutionException中重新抛出。
public class ExecuteCaught
{
public static void main(String[] args)
{
ExecutorService exec = Executors.newCachedThreadPool();
exec.execute(new ThreadPoolTask());
exec.shutdown();
}
}
class ThreadPoolTask implements Runnable
{
@Override
public void run()
{
Thread.currentThread().setUncaughtExceptionHandler(new ExceptionHandler());
System.out.println(3/2);
System.out.println(3/0);
System.out.println(3/1);
}
}
扩展阅读: