多线程进阶004 之 任务取消(一)

如果外部代码能在某个操作正常完成之前将其置入”完成”状态,那么这个操作就可以称为可取消的,取消某个操作的原因有很多:
用户请求取消: 用户点击图形界面程序中的”取消”按钮,或者通过管理接口来发出取消请求.
有时间限制操作:例如,某个应用程序需要在有限时间内搜索问题空间,并在这个时间内选择最佳的解决方案.当计时器超时时,需要取消所有正在搜索的任务.
应用程序事件: 例如,应用程序对某个问题空间进行分解并搜索,从而使不同任务都可以搜索问题空间中的不同区域.当其中一个任务找到了解决方案时,其他所有的任务都将被取消.
错误: 网页爬虫程序搜索相关页面,并将页面或摘要数据保存到硬盘,当一个爬虫任务发生错误时,那么所有的搜索任务都会取消,此时有可能会记录它们当前状态,以便稍后启动.
关闭: 当一个程序或服务关闭时,必须对正在处理和等待处理的工作执行某种操作,在平缓关闭过程中,当前正在执行的任务将继续执行直到完成,而在立即关闭的过程中,当前任务则有可能取消.

使用volatile类型自定义取消

import java.math.BigInteger;import java.util.ArrayList;import java.util.List;public class PrimeGenerator implements Runnable{    private final List<BigInteger> primes = new ArrayList<BigInteger>();    private volatile boolean cancelled;    @Override    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<BigInteger> get(){        return new ArrayList<BigInteger>(primes);    }}

一个仅运行一秒钟的素数生成器

    static List<BigInteger> aSecondOfPrimes() throws InterruptedException{        PrimeGenerator generator = new PrimeGenerator();        new Thread(generator).start();        try{            Thread.sleep(1000);        }finally{            generator.cancel();        }        return generator.get();    }

不可靠的取消操作将把生产者置于阻塞操作中

PrimeGenerator中的取消机制最终会使得搜索素数的任务退出,但在退出过程中需要花费一定的时间,然而,如果使用这种方法的任务调用了一个阻塞方法,例如BlockingQueue.put,那么可能会产生一个更严重的问题,任务永远不会检查取消标志,因此永不结束.

public class BrokenPrimeProducer extends Thread{    private final BlockingQueue<BigInteger> queue;    private volatile boolean cancelled;    BrokenPrimeProducer(BlockingQueue<BigInteger> queue){        this.queue = queue;    }    @Override    public void run() {        BigInteger p = BigInteger.ONE;        try{            while(!cancelled){                /**                 * 当队列满了的时候                 * 生产者阻塞,如果要取消任务,                 * 调用cancel()这个方法是无法做到的,                 * 如果消费者消费过慢,或者是迟迟不消费,                 * 那么该任务就需要阻塞很久,直到消费者消费完毕才能取消.                 */                queue.put(p = p.nextProbablePrime());            }        }catch(InterruptedException e){}    }    public void cancel(){        cancelled = true;    }    static void consumePrimes(BlockingQueue<BigInteger> primes) throws InterruptedException{        BrokenPrimeProducer producer = new BrokenPrimeProducer(primes);        producer.start();        try{            while(needMorePrimes()){                consume(primes.take());            }        }finally{            producer.cancel();        }    }    private static void consume(BigInteger take) {        /**         * 假设消费时间很长很长         */    }    private static boolean needMorePrimes() {        return false;    }}

中断是实现取消最合理的方式

理解: 它并不会真正中断一个正在运行的线程,而只是发出中断请求,然后由线程在下一个合适的时刻中断自己.

public class PrimeProducer extends Thread{    private final BlockingQueue<BigInteger> queue;    PrimeProducer(BlockingQueue<BigInteger> queue){        this.queue = queue;    }    @Override    public void run() {        try{            BigInteger p = BigInteger.ONE;            /**             * 这里并不一定需要显式的检测,             * 但执行检测却会使PrimeProducer对中断具有更高的响应性             */            while(!Thread.currentThread().isInterrupted())                queue.put(p = p.nextProbablePrime());        }catch(InterruptedException e){            /**             * 允许线程退出             */        }    }}