newFixedThreadPool与Callable结合用法

package com.sohu.test;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

/**
 * @author qiaowang
 * @date 2013-12-26 上午10:39:01
 */
public class TestThreadDemo {

    private ExecutorService exec;
    private int cpuNum;
    private List<Future<Long>> tasks = new ArrayList<Future<Long>>();

    class SumCalculator implements Callable<Long> {  
        private int[] numbers;  
        private int start;  
        private int end;  

        public SumCalculator(final int[] numbers, int start, int end) {  
            this.numbers = numbers;  
            this.start = start;  
            this.end = end;  
        }  

        public Long call() throws Exception {  
            Long sum = 0l;  
            for (int i = start; i < end; i++) {  
                sum += numbers[i];  
            }  
            return sum;  
        }  
    }   

    public TestThreadDemo() {
        cpuNum = Runtime.getRuntime().availableProcessors();
        exec = Executors.newFixedThreadPool(cpuNum);
    }

    public Long sum(final int[] numbers) {  
        // 根据CPU核心个数拆分任务，创建FutureTask并提交到Executor  
        System.out.println(cpuNum);
        for (int i = 0; i < cpuNum; i++) {  
            int increment = numbers.length / cpuNum + 1;  
            int start = increment * i;  
            int end = increment * i + increment;  
            if (end > numbers.length)  
                end = numbers.length;  
            SumCalculator subCalc = new SumCalculator(numbers, start, end);  
            FutureTask<Long> task = new FutureTask<Long>(subCalc);  
            tasks.add(task);  
            if (!exec.isShutdown()) {  
                exec.submit(task);  
            }  
        }  
        return getResult();  
    }

    public Long getResult() {
        Long result = 0l;
        for(Future<Long> task : tasks){
            try {
                Long subSum = task.get();
                result +=subSum;
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return result;
    }

    public void close(){
        exec.shutdown();
    }

    public static void main(String args[]){
        int[] numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 10, 11 ,12};  
        TestThreadDemo calc = new TestThreadDemo();  
        Long sum = calc.sum(numbers);  
        System.out.println(sum);  
        calc.close(); 
    }
}

参见
http://www.iteye.com/topic/366591

Executors类，提供了一系列工厂方法用于创先线程池，返回的线程池都实现了ExecutorService接口。
public static ExecutorService newFixedThreadPool(int nThreads)
创建固定数目线程的线程池。
public static ExecutorService newCachedThreadPool()
创建一个可缓存的线程池，调用execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
public static ExecutorService newSingleThreadExecutor()
创建一个单线程化的Executor。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。