java并发编程第四章 线程执行器（4）

8.在执行器中取消任务
使用执行器时，不需要管理线程，只需要实现Runnable或者Callable任务并发送任务给执行器即可。执行器负责创建线程，
管理线程池中的线程，当线程不再需要时就销毁它们。
可以使用Future接口中的cancel方法将任务取消。根据调用该方法时锁传递的参数以及任务的状态，这个方法的行为有些不同。
1.如果任务已经完成，或者之前已经被取消，或者由于某些原因不能被取消，那么方法将返回false并且任务也不能取消。
2.如果任务爱执行器中等待分配Thread对象来执行它，那么任务被取消，并且不会开始执行。如果任务已经在运行，
那么它依赖于调用cancel方法时所传递的参数，
如果为true则运行的该任务被取消。如果传递的参数为false，该运行的任务不会被取消。
备注：如果Future对象所控制的任务已经被取消，那么使用Future对象的get()方法时将抛出CancellationException异常。

实例代码：

/**
 * 
 * @author fcs
 * @date 2015-5-8
 * 描述：在执行器中取消任务
 * 说明：有时候我们可能要取消已经发送给执行器的任务，。在这种情况下，可以使用Future的cancel()方法
 * 来执行取消操作
 */
public class Task implements Callable<String>{

    @Override
    public String call() throws Exception {
        while(true){
            System.out.printf("Task: Test\n");
            Thread.sleep(100);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        ThreadPoolExecutor  executor = (ThreadPoolExecutor)Executors.newCachedThreadPool();

        Task task = new Task();
        System.out.println("Main: Executing the task\n");
        //调用该方法将任务发送给执行器
        Future<String> result = executor.submit(task);
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Main: Canceling the Task\n");
        //执行器的submit方法返回名为result的Future对象，调用Future对象的cancel方法来取消任务的执行。
        result.cancel(true);

        //这两个方法验证任务是否被取消和已完成
        System.out.printf("Main: Cancelled: %s\n",result.isCancelled());
        System.out.printf("Main: Done: %s\n",result.isDone());

        executor.shutdown();    //结束执行器

        System.out.println("Main: The executor has finished\n");

    }
}

9.在执行器中控制任务的完成
FutureTask类提供了一个名为done()的方法，允许在执行器中的任务执行结束后，还可以执行一些代码。
这个方法可以被用来执行一些后期处理操作。
比如产生报表，通过邮件发送结果或者释放一些系统资源。当任务执行完成是受FutureTask类控制时，
这个方法在内部被FutureTask类调用。
在任务结果设置后以及任务的状态以改变为isDone()之后，无论任务是否被取消，或者正常结束，done()方法才被调用。
默认情况下，done()方法的实现为空，即没有任何具体的代码实现，我们可以覆盖FutureTask类并实现done()方法来改变这种行为。
说明：一般就是继承FutureTask类重写该done()方法
在创建好返回值以及改变任务状态为isDone之后，FutureTask类就会在内部调用done()方法，虽然我们无法改变任务的结果值，
也无法改变任务的状态，但是可以通过任务来关闭系统
资源，输出日志信息，发送通知等。
实例代码：

/**
 * 
 * @author fcs
 * @date 2015-5-8
 * 描述：在控制器中控制任务的完成
 * 说明：FutureTask类提供一个名为done()的方法，允许在执行器中的任务执行结束之后
 * 还可以执行一些代码，这个方法可以被用来执行一些后期处理操作。
 * 该方法默认的实现为空，我们可以继承该方法并重写该方法
 */
public class ExecutableTask implements Callable<String>{
    private String name;


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

    @Override
    public String call() throws Exception {
        long duration = (long)(Math.random()*10);
        System.out.printf("%s: waiting %d seconds for results.\n",this.name,duration);
        TimeUnit.SECONDS.sleep(duration);
        return "Hello, world. I am"+name;
    }

    public String getName(){
        return name;
    }
}

/**
 * 
 * @author fcs
 * @date 2015-5-8
 * 描述：该类继承FutureTask并重写done()方法，该方法可以被用来执行一些后期操作
 * 说明：在创建好返回值以及改变任务状态为isDone()之后，FutureTask类就会在内部调用
 * done()方法。虽然我们无法改变任务的结果值，也无法改变任务的状态，但是可以通过任务来关闭系统
 * 资源，输出日志信息，发送通知等。
 */
public class ResultTask extends FutureTask<String>{
    private String name;
    public ResultTask(Callable<String> callable){
        super(callable);
        this.name =((ExecutableTask)callable).getName();
    }

    @Override
    protected void done() {
        if(isCancelled()){
            System.out.printf("%s: Has been canceld\n",name);

        }else{
            System.out.printf("%s: Has finished\n",name);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        ExecutorService executor = (ExecutorService)Executors.newCachedThreadPool();
        ResultTask resultTask [] = new ResultTask[5];
        for(int i = 0;i < 5;i++ ){
            //这里必须创建ExecutorTask 对象，然后创建ResultTask对象来使用ExecutorTask对象，最后调用
            //submit()方法将ResultTask发送给执行器
            ExecutableTask executableTask = new ExecutableTask("Task"+i);
            resultTask[i] = new ResultTask(executableTask); 

            executor.submit(resultTask[i]);
        }

        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //取消任务的运行
        for(int i =0 ;i < resultTask.length;i++){
            resultTask[i].cancel(true);
        } 

        //通过调用ResultTask对象的get()方法，在控制台上输出还没有被取消的任务的结果
        for(int i =0;i < resultTask.length;i++){
            try {
                //这里会报异常：java.util.concurrent.CancellationException
                if(resultTask[i].isCancelled()){
                    System.out.printf("%s\n",resultTask[i].get());
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
        executor.shutdown();//结束执行器
    }
}