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

10.在执行器中分离任务的启动与结果的处理
当我们要在一个对象中发送任务给执行器，在另一个对象中处理结果时，对于这种需求可以使用CompletionService类。
该类有一个方法用来发送任务给执行器，还有一个方法为下一个已经执行结束的任务获取Future对象。从内部实现机制来看，CompletionService类使用Executor对象来执行任务。
这个行为
的优势是可以共享CompletionService对象，并发送任务到执行器，然后其他的对象可以处理任务的结果。第二个方法有不足之处，只能为已经执行结束的任务获取Future对象，因此，
这些Future对象只能被用来获取任务的结果。
该类可以执行Callable或者Runnable类型的任务。由于使用Runnable接口对象不能产生结果，因此CompletionService的基本原则不适用。
CompletionService类提供了其他两种方法来获取任务已经完成的Future对象。
1.poll()：无参数的poll()方法用于检查队列中是否有Future对象。如果队列为空，则立即返回null，否则将返回队列中的第一个元素，并移除该元素。
2.take(): 这个方法检查队列中是否有Future对象。如果队列为空，则会阻塞线程直到队列中有可用的元素。如果队列中有元素，它将返回队列中的第一个元素，并移除该元素。

/**
 * 
 * @author fcs
 * @date 2015-5-8
 * 描述：在执行器中分离任务的启动与结果的处理
 * 说明：使用需求：需要在一个对象里发送任务给执行器，然后在另一个对象里处理结果
 */
public class ReportGenerator implements Callable<String>{
    private String sender;
    private String title;
    public ReportGenerator(String sender, String title) {
        this.sender = sender;
        this.title = title;
    }

    @Override
    public String call() throws Exception {

        long duration = (long)(Math.random()*10);
        System.out.printf("%s_%s: ReportGenerator: Generating a report during %d seconds\n",this.sender,this.title,duration);;
        TimeUnit.SECONDS.sleep(duration);
        String ret = sender+":"+title;
        return ret;
    }
}

/**
 * 
 * @author fcs
 * @date 2015-6-16
 * 描述：该类将获取到ReportGenerator任务的结果
 */
public class ReportProcessor implements Runnable{
    private CompletionService<String> service;
    private boolean end;
    public ReportProcessor(CompletionService<String> service) {
        this.service = service;
        end = false;
    }

    @Override
    public void run() {
        while(!end){
            try {
                //调用CompletionService的poll()方法来获取下一个已经完成任务的Future对象
                Future<String> result = service.poll(20, TimeUnit.SECONDS);
                if(result != null){
                    String report;
                         //使用该方法获取任务的结果。
                        report = result.get();

                    System.out.printf("ReportReceiver: Report Received: %s\n",report);
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("ReportSender: End\n");
        }
    }

    public void setEnd(boolean end){
        this.end = end;
    }

}

/**
 * 
 * @author fcs
 * @date 2015-5-9
 * 描述：模拟请求报告
 */
public class ReportRequest implements Runnable {
    private String name;

    private CompletionService<String>  service;

    public ReportRequest(String name, CompletionService<String> service) {
        this.name = name;
        this.service = service;
    }

    /**
     * 调用service的submi()方法将ReportGenerator对象发送给CompletionService对象
     */
    @Override
    public void run() {
        ReportGenerator  reportGenerator = new ReportGenerator(name, "Report");
        service.submit(reportGenerator);

    }
}

public class Main {
    public static void main(String[] args) {
        ExecutorService  executorService = (ExecutorService)Executors.newCachedThreadPool();
        CompletionService<String> service = new ExecutorCompletionService<String>(executorService);

        //创建两个ReportRequest对象，然后创建两个线程Thread对象分别执行他们
        ReportRequest  faceRequest = new ReportRequest("Face", service);
        ReportRequest onlineRequest = new ReportRequest("Online",service);

        Thread faceThread = new Thread(faceRequest);
        Thread onlineThread = new Thread(onlineRequest);
        ReportProcessor processor = new ReportProcessor(service);
        Thread senderThread = new Thread(processor);
        System.out.println("Main: Starting the Threads\n");

        faceThread.start();
        onlineThread.start();
        senderThread.start();

        System.out.println("Main: Waiting for the report generators.\n");
        //等待ReportRequest线程的结束
        try {
            faceThread.join();
            onlineThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.printf("Main: Shutting down the executor.\n");
        executorService.shutdown();
        try {
            //调用该方法等待所有的任务执行结束
            executorService.awaitTermination(1, TimeUnit.DAYS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        processor.setEnd(true);
        System.out.println("Main: Ends");

    }
}

11.处理在执行器中被拒绝的任务
如果在shutdown()方法与执行器结束之间发送一个任务给执行器，这个任务会被拒绝，因为这个时间段执行器不再接收任务了，
ThreadPoolExecutor类提供了一套机制，当任务被拒绝时调用
这套机制来处理它们。
使用RejectedExecutionHandler接口。
为了处理在执行器中被拒绝的任务，需要创建一个实现RejectedExecutionHandler接口的处理类。这个接口有一个rejectedExecution方法，其中有两个参数：
1.一个Runnable对象，用来存储被拒绝的任务，。
2.一个Executor对象，用来存储任务被拒绝的执行器。
被执行器拒绝的每一个任务都将调用该方法，需要先调用Executor类的setRejectedExecutionHandler()方法来设置用于被拒绝的任务的处理程序。
当执行器接收一个任务并开始执行时，先检查shutdown()方法是否已经被调用了，如果是那么执行器就会拒绝这个任务。首先，执行器会寻找通过setRejectedExecutionHandler()方法设置的
用于被拒绝的任务的处理程序，如果找到一个处理程序，执行器就会调用其rejectedExecution()方法，否则就会抛出RejectedExecutionException异常,这是一个运行时异常，
因此并不需要catch语句来对其进行处理。

/**
 * 
 * @author fcs
 * @date 2015-5-9
 * 描述：处理在执行器中被拒绝的任务
 * 说明：当我们想结束执行器的执行时，调用shutdown()方法来表示执行器应当结束，但是，执行器只有等待
 * 正在运行的任务或者等待执行的任务结束后，才能真正结束。
 * 如果在shutdown()方法与执行器结束之间发送一个任务给执行器，这个任务会被拒绝，
 * 因为这个时间段执行器已经不再接受任务了，ThreadPoolExecutor类提供了一套机制，
 * 当任务呗拒绝时调用这套机制来处理它们
 * 本节使用RejectedExecutionHandler接口，该接口只有一个方法
 * rejectedExecution方法
 *
 */
public class RejectedTaskController implements RejectedExecutionHandler{

    @Override  //在控制台输出已被拒绝的任务的名称和执行器的状态
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.out.printf("RejectedTaskController: The task %s has been rejected \n",r.toString());
        System.out.printf("RejectedTaskController: %s\n",executor.toString());
        System.out.printf("RejectedTaskController: Terminating: %s\n",executor.isTerminating());
        System.out.printf("RejectedTaskController: Terminated: %s\n",executor.isTerminated());
    }
}

public class Task implements Runnable{
    private String name;

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

    @Override
    public void run() {
        System.out.println("Task "+name+ ": starting");
        long duration = (long)(Math.random() *10);
        System.out.printf("Task %s: ReportGenerator: Generatint a report during %d seconds\n",name,duration);
        try {
            TimeUnit.SECONDS.sleep(duration);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.printf("Task %s: Ending \n",name);
    }

    @Override   //重写toString方法，返回任务的名称
    public String toString() {
        return name;
    }
}

public class Main {
    public static void main(String[] args) {
        RejectedTaskController  controller = new RejectedTaskController();
        ThreadPoolExecutor  executor = (ThreadPoolExecutor)Executors.newCachedThreadPool();
        //设置用于被拒绝的任务的处理程序
        executor.setRejectedExecutionHandler(controller);
        System.out.printf("Main: Starting.\n");
        for(int i =0;i< 3;i++){
            Task task = new Task("Task_"+i);
            executor.submit(task);
        }
        System.out.println("Main:Shutting down the executor.\n");
        executor.shutdown();

        System.out.println("Main: Sending another Task\n");

        //关闭执行器后再发送一个任务给执行器
        Task task = new Task("RejectedTask");
        executor.submit(task);

        System.out.println("Main: End.");

    }
}