package java.util.concurrent;

/**

 *一个带有返回结果并可能引发异常的任务.实现定义了一个没有调用参数

 *的方法call。

 *Callable接口类似于{@link java.lang.Runnable}，因为它们都是为其

 *实例可能被另一个线程执行的类设计的。然而，Runnable不返回结果，

 *也不能抛出被检查的异常。{@link Executors}类包含从其他常用形式

 *转换为Callable类的实用程序方法。

  */

public interface Callable<V> {

    /**

    * 计算一个结果，如果不能这样做，就会抛出一个异常。.

    *

    * @return 结算结果

    * @throws 如果无法计算结果，则抛出异常

    */

    V call() throws Exception;

}

public interface Future<V> {

    /**

    * 尝试取消执行此任务。 如果任务已经完成，已经被取消或由于某种其他原因而无法取消，则此尝试将失败。

    * 如果成功，并且调用<tt> cancel </ tt>时，此任务尚未启动，则此任务不应运行。 如果任务已经开始，

    * 那么<tt> mayInterruptIfRunning </ tt>参数决定了执行该任务的线程是否应该被中断以试图停止该任务。

    */

    boolean cancel( boolean mayInterruptIfRunning );

    /**

     * 如果此任务在正常完成之前已被取消，返回true

     * @return <tt>true</tt> 如果此任务在正常完成之前已被取消，返回true

     */

    boolean isCancelled();

    /**

     * 如果任务已经完成返回true

     * 完成可能是由于正常终止，异常或异常 - 在所有这些情况下，此方法都将返回<tt> true </ tt>。

     * @return <tt>true</tt> 如果任务已经完成返回true

     */

    boolean isDone();

    /**

     * 等待计算完成，然后获得其结果。

     *

     */

    V get() throws InterruptedException, ExecutionException;

    /**

     * 如果需要等待最多在给定的时间计算完成，然后检索其结果（如果可用）。

     *

     */

    V get( long timeout, TimeUnit unit )

    throws InterruptedException, ExecutionException, TimeoutException;

}

public static ExecutorService newFixedThreadPool( int nThreads )

{

    return(new ThreadPoolExecutor( nThreads, nThreads,

                       0L, TimeUnit.MILLISECONDS,

                       new LinkedBlockingQueue<Runnable>() ) );

}

public ThreadPoolExecutor( int corePoolSize,

               int maximumPoolSize,

               long keepAliveTime,

               TimeUnit unit,

               BlockingQueue<Runnable> workQueue )

{

    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,

         Executors.defaultThreadFactory(), defaultHandler);

}

public ThreadPoolExecutor( int corePoolSize,

               int maximumPoolSize,

               long keepAliveTime,

               TimeUnit unit,

               BlockingQueue<Runnable> workQueue,

               ThreadFactory threadFactory,

               RejectedExecutionHandler handler )

{

    if ( corePoolSize < 0 ||

         maximumPoolSize <= 0 ||

         maximumPoolSize < corePoolSize ||

         keepAliveTime < 0 )

        throw new IllegalArgumentException();

    if ( workQueue == null || threadFactory == null || handler == null )

        throw new NullPointerException();

    this.corePoolSize    = corePoolSize;

    this.maximumPoolSize    = maximumPoolSize;

    this.workQueue        = workQueue;

    this.keepAliveTime    = unit.toNanos( keepAliveTime );

    this.threadFactory    = threadFactory;

    this.handler        = handler;

}

package com.roc.thread;

import java.util.ArrayList;

import java.util.List;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

public class FixedThreadPoolTest {

    public static void main( String[] args )

    {

        FixedThreadPoolTest fixedThreadPoolTest = new FixedThreadPoolTest();

        fixedThreadPoolTest.execut();

    }

    private void execut()

    {

        ExecutorService        executorService = Executors.newFixedThreadPool( 10 );/* 创建为10个线程的固定线程池 */

        List<Integer>        datas        = new ArrayList<Integer>( 100 );

        List<Future<Integer> >    results        = new ArrayList<Future<Integer> >();

        int            count        = 0;

        for ( int i = 0; i < 100; i++ )/* 实际项目中数据可以查数据库或者文件，这里仅仅表示模拟 */

        {

            datas.add( i );

        }

        for ( int i = 0; i < datas.size(); i++ )

        {

            results.add( executorService.submit( new executTask( datas.get( i ) ) ) );

        }

        try {

            for ( Future<Integer> future : results )

            {

                count += future.get();

            }

        } catch ( InterruptedException e ) {

            /* TODO Auto-generated catch block */

            e.printStackTrace();

        } catch ( ExecutionException e ) {

            /* TODO Auto-generated catch block */

            e.printStackTrace();

        }

        System.out.println( Thread.currentThread() + "处理数据总数：" + count );

    }

    class executTask implements Callable<Integer> {

        private int data;

        public executTask( int data )

        {

            this.data = data;

        }

        @Override

        public Integer call() throws Exception

        {

            try {

                System.out.println( Thread.currentThread() + "处理完数据：" + data ); /* 实际项目中这里可以处理业务逻辑 */

            } catch ( Exception e ) {

                return(-1);

            }

            return(1);

        }

    }

}