多线程进阶006 之 停止基于线程服务

如果应用程序准备退出,那么这些服务所拥有的线程也需要结束,本节将讲述以下技巧:

• 关闭日志服务
  – 不支持关闭的日志服务
  – 通过一种不可靠的方式增加关闭操作
  – 可靠的取消操作
• 关闭ExecutorService
• 毒丸对象
• 只执行一次的服务
• shutdownNow的局限性
  – 在ExecutorService跟踪在关闭之后取消的任务
  – 使用TrackingExecutorService来保存未完成的任务

关闭日志服务

不可关闭的日志服务

基于生产者消费者的日志服务

public class LogWriter {    private final BlockingQueue<String> queue;    private final LoggerThread logger;    public LogWriter(Writer writer){        this.queue = new LinkedBlockingQueue<>();        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 = (PrintWriter) writer;        }        //....        @Override        public void run() {            try{                while(true){                    writer.println(queue.take());                }            }catch (InterruptedException e){                //...            }finally{                writer.close();            }        }    }}

为了使像LogWriter这样的服务在软件产品中能发挥实际作用,还需要实现一种终止日志线程的方法,从而避免使JVM无法正常关闭.

不可靠的方式增加关闭服务

如果将日志线程修改为捕获到InterruptedException时退出,那么只需要中断日志线程就能停止服务.

public void log(String msg) throws InterruptedException{        if(!isShutdown())            queue.put(msg);        else            throw new IllegalStateException("logger is shut down");    }    public void shutdown(){        logger.interrupt();    }    public boolean isShutdown(){        return !logger.isAlive();    }

这种直接关闭的做法会丢失那些正在等待被写入到日志的信息,不仅如此,其他线程将在调用log时被阻塞,因为日志消息队列是满的,因此这些线程无法解除阻塞状态.

向LogWriter添加可靠的取消操作

为LogWriter提供一个可靠关闭操作的方法是解决竞态条件问题,因而要是日志消息的提操作成为原子操作.然而,我们不希望在消息加入队列时去持有一个锁,因为put方法本身就可以阻塞.
通过原子方式来检查关闭请求,并且有条件地递增一个计数器来保持提交消息的权利.

public class LogService {    private final BlockingQueue<String> queue;    private final LoggerThread loggerThread;    private final PrintWriter writer;    private boolean isShutdown;    private int reservations;    public LogService(Writer writer){        queue = new LinkedBlockingQueue<>();        loggerThread = new LoggerThread();        this.writer = (PrintWriter) writer;        isShutdown = false;        reservations = 0;    }    public void start(){        loggerThread.start();    }    public void log(String msg) throws InterruptedException{        synchronized (this) {            if(isShutdown){                throw new IllegalStateException("logger is shut down");            }            ++reservations;        }        queue.put(msg);    }    public void stop(){        synchronized (this) {            isShutdown = true;        }        loggerThread.interrupt();    }    private class LoggerThread extends Thread{        //....        @Override        public void run() {            try{                while(true){                    synchronized (LogService.this) {                        if(isShutdown && reservations==0){                            break;                        }                    }                    String msg = queue.take();                    synchronized (LogService.this) {                        --reservations;                    }                    writer.println(msg);                }            }catch (InterruptedException e){                //...            }finally{                writer.close();            }        }    }}

关闭ExecutorService

简单的程序可以直接在main函数中启动和关闭全局的Executor,而在复杂的程序中,通常会将ExecutorService封装在某个更高级别的服务中,并且该服务能提供其自己的生命周期的办法.

try{    exec.shutdown();    exec.awaitTermination(TIMEOUT,UNIT);}finally{    writer.close();}

毒丸对象

另一种生产者消费者服务的方式就是使用毒丸对象: 毒丸是指放在队列上的一个对象,其含义是: 当得到这个对象时,立即停止.

public class IndexingService {    private static final File POISON = new File("");    private final IndexerThread consumer = new IndexerThread();    private final CrawlerThread producer = new CrawlerThread();    private final BlockingQueue<File> queue;    private final File root;    public IndexingService(File root) {        queue = new LinkedBlockingQueue<>();        this.root = root;    }    public void start(){        producer.start();        consumer.start();    }    public void stop(){        producer.interrupt();    }    public void awaitTermination() throws InterruptedException{        consumer.join();    }    public class CrawlerThread extends Thread{        @Override        public void run() {            try{                crawl(root);            }catch(InterruptedException e){                /*发生异常*/            }finally{                while(true){                    try{                        queue.put(POISON);                        break;                    }catch(InterruptedException e){                        /* 重新尝试 */                    }                }            }        }        private void crawl(File root) throws InterruptedException{            // ...        }    }    public class IndexerThread extends Thread{        @Override        public void run() {            try{                while(true){                    File file = queue.take();                    if(file==POISON){                        break;                    }                    else                        IndexFile(file);                }            }catch(InterruptedException e){                /*发生异常*/            }        }        private void IndexFile(File file) {            //...        }    }}

只有在生产者消费者的数量都已知的情况下,才可以使用”毒丸”对象.

只执行一次的服务

如果某个方法需要处理一匹任务,并且当所有的任务都处理完后才返回,那么可以通过一个私有的Executor来简化服务的生命周期.

boolean checkEmail(Set<String> hosts,long timeout,TimeUnit unit) throws InterruptedException{    ExecutorService exec = Executors.newCachedThreadPool();    final AtomicBoolean hasNewMail = new AtomicBoolean(false);    try{        for(final String host : hosts){            exec.execute(new Runnable(){                @Override                public void run() {                    if(checkMail(host)){                        hasNewMail.set(true);                    }                }            });        }    }finally{        exec.shutdown();        exec.awaitTermination(timeout, unit);    }    return hasNewMail.get();}protected boolean checkMail(String host) {    return false;}

shutdownNow的局限性

通过shutdownNow来强行关闭ExecutorService时,它会尝试取消正在执行的任务,并返回所有已提交但尚未开始的任务,从而我们可以将这些任务写入日志或保存起来以便之后进行处理.但是,它并不会返回正在执行,但是没有执行完毕的任务.

在ExecutorService中跟踪在关闭之后取消的任务

TrackingExecutor可以找出哪些任务已经开始,还没有完成.在所有设计良好的任务中,都会实现这个功能.

public class TrackingExecutor {    private final ExecutorService exec;    private final Set<Runnable> taskCancelledAtShutdown = Collections.synchronizedSet(new HashSet<Runnable>());    public TrackingExecutor(ExecutorService exec) {        this.exec = exec;    }    public List<Runnable> getCancelledTask(){        if(!exec.isTerminated()){            throw new IllegalStateException();        }        return new ArrayList<>(taskCancelledAtShutdown);    }    public void execute(final Runnable runnable){        exec.execute(new Runnable(){            public void run() {                try{                    runnable.run();                }finally {                    if(isShutdown()&&Thread.currentThread().isInterrupted()){                        taskCancelledAtShutdown.add(runnable);                    }                }            }        });    }    //将ExecutorService的其他方法委托给exec    protected boolean isShutdown() {        return exec.isShutdown();    }}

使用TrackingExecutorService来保存未完成的任务

网页爬虫程序的工作通常是无穷无尽的,因此当爬虫程序必须关闭时,我们通常希望保存它的状态,以便稍后重新启动.

public abstract class WebCrawler {    private static final String TIMEOUT = null;    private static final String UNIT = null;    private volatile TrackingExecutor exec;    private final Set<URL> urlsToCrawl = new HashSet<URL>();    public synchronized void start(){        exec = new TrackingExecutor(Executors.newCachedThreadPool());        for (URL url : urlsToCrawl) {            submitCrawlTask(url);        }        urlsToCrawl.clear();    }    public synchronized void stop(){        try{            saveUncrawled(exec.shutdownNow());            if(exec.awaitTermination(TIMEOUT,UNIT))                saveUncrawled(exec.getCancelledTask());        }finally {            exec = null;        }    }    public void submitCrawlTask(URL link) {        exec.execute(new CrawlTask(link));    }    private void saveUncrawled(List<Runnable> c) {        for (Runnable task : c) {            urlsToCrawl.add(((CrawlTask) task).getPage());        }    }    protected abstract List<URL> processPage(URL url);    private class CrawlTask implements Runnable{        private final URL url;        public CrawlTask(URL url) {            this.url = url;        }        @Override        public void run() {            for(URL link : processPage(url)){                if(Thread.currentThread().isInterrupted())                    return ;                submitCrawlTask(link);            }        }        public URL getPage(){            return url;        }    }}

在TranckingExecutor中存在一个不可避免的竞态条件,从而产生误报问题,一些被认为已取消的任务实际上已经执行完成.这个原因在于,在执行任务最后一条指令以及线程池将任务记录为”结束”的两个时刻之间,线程池可能被关闭.