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类。

你可能感兴趣的:(ThreadPool)