[笔记][Java7并发编程实战手册]4.9-4.10在执行器中控制任务的完成和取消任务FutureTask

[笔记][Java7并发编程实战手册]系列目录

---

简介

在前面都是把需要执行的Runnable或则Callable提交给线程池，让线程池来管理任务的生命周期。在本章会学习：怎么取消任务的运行，在任务运行中，任务结束的时候怎么去处理一些事情，比如关闭资源，发送通知等。

本章心得

1. 继承可取消任务的FutureTask，复写done() 方法。使用done方法来处理任务非正常结束和正常结束的一些操作
2. 执行submit可接受一个Runnable任务，因此可使用 FutureTask 包装 Callable 或 Runnable 对象。因为 FutureTask 实现了 Runnable，所以可将 FutureTask 提交给 Executor 执行。

3. FutureTask.cancel(true/false) 取消任务的特性：

   1. true 和 false 的区别
      true ： 在休眠中的线程被true取消，则休眠后面的代码不会继续执行，get获取结果将会抛出CancellationException异常
      false： 在休眠中的线程被false取消，休眠后的代码会被继续执行，get获取结果同样会被抛出异常
   2. 取消正在正常运行的任务。比如task2中，一直while循环。则不会结束任务。所以只能用于周期性的任务取消。比较有明显的效果

4. Future也可以被取消，只是没有检测任务完成处理的钩子方法

---

示例

控制任务的完成和取消

/**
 * Created by zhuqiang on 2015/9/1 0001.
 */
public class sync4_7 {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService es = Executors.newCachedThreadPool();
        ResultTask t1 = new ResultTask(new Task("小强"));
        es.submit(t1);
        ResultTask t2 = new ResultTask(new Task("小小强"));
        es.submit(t2);

//        ResultTask t3 = new ResultTask(new Task2("循环任务，测试任务在正常执行中，会不会被强制取消"));
//        es.submit(t3);

        TimeUnit.SECONDS.sleep(1);  //主线程休眠1秒，然后取消t2任务
        t2.cancel(true); // 演示1：观察被取消的任务在调用done() 方法中的打印信息,true 和 false 的区别是：true:在休眠中，将被强制取消，不会继续下面的代码，而false，当前任务会执行完，只是获取结果会爬出异常
//        t3.cancel(true);
        es.shutdown();


        System.out.println("----------------  获取任务结果");
        System.out.println(t1.get());
        System.out.println(t2.get());  //演示2：未正常完成的任务，调用获取结果会抛出异常CancellationException
    }
}

/**
 * 继承FutureTask，
 */
class ResultTask extends FutureTask<String>{

    public ResultTask(Callable<String> callable) {
        super(callable);
    }

    public ResultTask(Runnable runnable, String result) {
        super(runnable, result);
    }

    //当此任务转换到状态 isDone（不管是正常地还是通过取消）时该方法会被调用。
    @Override
    protected void done() {
        System.out.println(Thread.currentThread().getName() + ",是否在正常完成前被取消：" + isCancelled());
    }
}

class Task implements Callable<String>{
    private String name;

    public Task(String name) {
        this.name = name;
    }

    @Override
    public String call() throws Exception {
        long time = (long)(Math.random()*10);
        System.out.printf("%s,%s,执行前，该任务将耗时:%s秒\n", Thread.currentThread().getName(), name, time);
        TimeUnit.SECONDS.sleep(time);  //随机休眠，让外面能有时间执行取消任务的代码
        System.out.printf("%s,%s,执行过了，耗时:%s秒\n", Thread.currentThread().getName(), name, time);
        return name;
    }
}
// 演示3 使用的类：正常的任务，不会被强制取消，只有线程等待获取中断会被取消
class Task2 implements Callable<String> {
    private String name;

    public Task2(String name) {
        this.name = name;
    }


    @Override
    public String call() throws Exception {
        boolean flag = true;
        while (flag){
            System.out.printf("%s,循环中\n",Thread.currentThread().getName());
            TimeUnit.SECONDS.sleep(2);  //演示3：正常的任务，不会被强制取消，只有线程等待获取中断会被取消
        }
        return name;
    }
}

某一次的运行结果：

pool-1-thread-1,小强,执行前，该任务将耗时:9秒
pool-1-thread-2,小小强,执行前，该任务将耗时:3秒
main,是否在正常完成前被取消：true
----------------  获取任务结果
pool-1-thread-1,小强,执行过了，耗时:9秒
Exception in thread "main" java.util.concurrent.CancellationException
pool-1-thread-1,是否在正常完成前被取消：false
    at java.util.concurrent.FutureTask.report(FutureTask.java:121)
小强
    at java.util.concurrent.FutureTask.get(FutureTask.java:192)
    at java7Concurrency.sync4_7.main(sync4_7.java:27)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:497)
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:140)

结果说明：
　　可以看到，t2在休眠中被取消了，后面的代码没有执行了。抛出的异常，是获取已经取消的任务抛出的异常。
但是如果 t2.cancel(false); ，来取消t2.t2会把当前任务正常的执行完。只是获取结果任然抛出异常