Executor framework的机制

从java5开始，java就提供了名叫Executor framework的机制,主要是围绕着Executor接口, 它的接口 ExecutorService, 以及实现了这两个接口的ThreadPoolExecutor类来展开，这种机制把线程的执行和创建分离开了，你只需要创建一个线程，然后把线程丢给Executor，让它执行去吧。使用这个机制的另外一个好处是可以使用Callable接口，它类似于Runnable接口，但是有两个不一样的特性。

• 它的主要方法是call(), 它可以携带一个返回值。
• 当你发送了一个Callable对象给executor之后，你可以拿到一个实现了Future接口的对象，通过这个对象，你可以控制对象的状态以及Callable对象的结果。

package threadPool.executorDemo;

import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

/**
 * 
 * 类似于Runnable接口,具有以下特点
 * 1 它的主要方法是call(), 它可以携带一个返回值。
 * 2 当你发送了一个Callable对象给executor之后，
 * 你可以拿到一个实现了Future接口的对象，通过这个对象，你可以控制对象的状态以及Callable对象的结果。
 * 
 * 3 Callable 接口类似于 Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。
 * 但是 Runnable 不会返回结果，并且无法抛出经过检查的异常。 
 * @version  [版本号, 2014-3-10]
 * @see  [相关类/方法]
 * @since  [产品/模块版本]
 */
public class FactorialCalculator implements Callable<Integer> {
    
    private Integer number;
    
    public FactorialCalculator(Integer number) {
        this.number = number;
    }
    
    @Override
    public Integer call() throws Exception {
        int result = 1;
        if ((number == 0) || (number == 1)) {
            result = 1;
        }
        else {
            for (int i = 2; i <= number; i++) {
                result *= i;
                TimeUnit.MILLISECONDS.sleep(50L);
            }
        }
        System.out.printf("%s: %d\n", Thread.currentThread().getName(), result);
        return result;
    }
}

package threadPool.executorDemo;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;

public class TestDemo3 {
    
    /** 
     * 数的阶乘 n!
     * <功能详细描述>
     * @param args
     * @see [类、类#方法、类#成员]
     */
    public static void main(String[] args) {
        //创建了两条线程
        ThreadPoolExecutor pool = (ThreadPoolExecutor)Executors.newFixedThreadPool(2);
        
        //添加线程池关闭后出现的异常处理
        pool.setRejectedExecutionHandler(new RejectedTaskController());
        
        //用于存放Future接口的对象容器
        List<Future<Integer>> resultList = new ArrayList<Future<Integer>>();
        
        FactorialCalculator calculator = new FactorialCalculator(6 );
        
        //提交一个返回值的任务用于执行，返回一个表示任务的未决结果的 Future
        //Future接口 表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果
        Future<Integer> result = pool.submit(calculator);
        resultList.add(result);
        
        FactorialCalculator calculator1 = new FactorialCalculator(5);
        Future<Integer> result1 = pool.submit(calculator1);
        resultList.add(result1);
        
        for (int i = 0; i < resultList.size(); i++) {
            result = resultList.get(i);
            Integer number = null;
            try {
                //如有必要，等待计算完成，然后获取其结果
                number = result.get();
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
            catch (ExecutionException e) {
                e.printStackTrace();
            }
            System.out.printf("Main: Task %d: %d\n", i, number);
        }
        //关闭线程池
        //按过去执行已提交任务的顺序发起一个有序的关闭，但是不接受新任务
        pool.shutdown();
    }
    
}

package threadPool.executorDemo;

import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * 
 * 当线程池关闭后，用来处理线程异常
 * <功能详细描述>
 *
 * @version  [版本号, 2014-3-10]
 * @see  [相关类/方法]
 * @since  [产品/模块版本]
 */
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());
        
        //如果此执行程序处于在 shutdown 或 shutdownNow 之后正在终止但尚未完全终止的过程中，则返回 true
        System.out.printf("RejectedTaskController: Terminating: %s\n", executor.isTerminating());
        
        //如果关闭后所有任务都已完成，则返回 true
        System.out.printf("RejectedTaksController: Terminated: %s\n", executor.isTerminated());
    }
}