lsbwahaha

并发编程的一种编程方式是把任务拆分为一些列的小任务，即Runnable，然后在提交给一个Executor执行，Executor.execute(Runnalbe) 。Executor在执行时使用内部的线程池完成操作。

     例子：
              有一个很大的整数数组，需要求这个数组中所有整数的和，来计算结果。  
             （JDK 7 中的 Fork/Join模式可以解决该问题，http://www.ibm.com/developerworks/cn/java/j-lo-forkjoin/)

     分析：
             采用多线程(任务)，并且还要分割List，每一小块的数组采用一个线程(任务)进行计算其和，那么我们必须要等待所有的线程(任务)完成之后才能得到正确的结果.

步骤：

• 分割数组，根据采用的线程(任务)数平均分配，即array.length/threadCounts。
• 定义一个记录“很大数组”中所有整数和的变量sum，采用一个线程(任务)处理一个分割后的子数组，计算子数组中所有整数和(subSum)，然后把和(subSum)累加到sum上。
• 等待所有线程(任务)完成后输出总和(sum)的值。

/** *//**
 * 并行计算数组的和, 测试类
 * 
 * @author lsb
 *
 */
public class MainTest {
    public static void main(String[] args) {
        int[] numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 10, 11 };
        CalcArrayTotal calc = new CalcArrayTotal();
        Long sum = calc.sum(numbers);
        System.out.println(sum);
        calc.close();
    }
}

主要实现类：

import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import com.li.senbiao.Thread.concurrent.test1.SumCalculator;

public class CalcArrayTotal {

    private ExecutorService exec;

    private CompletionService<Long> completionService;

    private int cpuCoreNumber;

    public CalcArrayTotal() {
        cpuCoreNumber = Runtime.getRuntime().availableProcessors();
        exec = Executors.newFixedThreadPool(cpuCoreNumber);
        completionService = new ExecutorCompletionService<Long>(exec);
    }

    public Long sum(final int[] numbers) {
        // 根据CPU核心个数拆分任务，创建FutureTask并提交到Executor
        for (int i = 0; i < cpuCoreNumber; i++) {
            int increment = numbers.length / cpuCoreNumber + 1;
            int start = increment * i;
            int end = increment * i + increment;
            if (end > numbers.length) {
                end = numbers.length;
            }
            SumCalculator subCalc = new SumCalculator(numbers, start, end);
            if (!exec.isShutdown()) {
                /** *//**
                 * 生产者 submit() 执行的 任务。使用者 take() 已完成的任务， 
                 * 并按照完成这些任务的顺序处理它们的结果  。
                 * 也就是调用CompletionService 的 take 方法是，
                 * 会返回按完成顺序放回任务的结果， CompletionService 内部维护了一个 阻塞队列 BlockingQueue ，
                 * 如果没有任务完成， take() 方法也会阻塞。
                 */
                completionService.submit(subCalc);
            }
        }
        return getResult();
    }

    /** *//**
     * 迭代每个只任务，获得部分和，相加返回
     */
    public Long getResult() {
        Long result = 0L;
        for (int i = 0; i < cpuCoreNumber; i++) {
            try {
                Long subSum = completionService.take().get();
                result += subSum;
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
        return result;
    }

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

}

一组的计算和：

import java.util.concurrent.Callable;

/** *//**
 * 一组计算和值 
 * 
 * @author lsb
 *
 */
public 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;
    }

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

        Executors类，提供了一系列工厂方法用于创先线程池，返回的线程池都实现了ExecutorService接口。

         // 创建固定数目线程的线程池
        public static ExecutorService newFixedThreadPool(int nThreads)

       
        // 创建一个可缓存的线程池，调用execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。

        public static ExecutorService newCachedThreadPool() 
    
        // 创建一个单线程化的Executor

        public static ExecutorService newSingleThreadExecutor()

       
       //  创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类

        public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

   二、ExecutorService 与生命周期

      ExecutorService 扩展了Executor 并添加了一些生命周期管理的方法。一个Executor 的生命周期有三种状态，运行 ，关闭 ，终止 。Executor 创建时处于运行状态。当调用ExecutorService.shutdown() 后，处于关闭状态，isShutdown() 方法返 回true 。这时，不应该再想Executor 中添加任务，所有已添加的任务执行完毕后，Executor 处于终止状态，isTerminated() 返 回true 。

   如果Executor 处于关闭状态，往Executor 提交任务会抛出unchecked exception RejectedExecutionException 。

    三、使用Callable ，Future 返回结果

     Future<V> 代表一个异步执行的操作，通过get() 方法可以获得操作的结果，如果异步操作还没有完成，则，get() 会使当前 线程阻塞。FutureTask<V> 实现了Future<V> 和Runable<V> 。Callable 代表一个 有返回值得操作。

ExecutoreService 提供了submit() 方法，传递一个Callable ，或Runnable ，返回Future 。如果Executor 后台线程池还没有完成Callable 的计算，这调用返回Future 对象的get() 方法，会阻塞直到计算完成。