Java并发编程之——线程池帮助类Executors和Future及Callable相关

Future和FutureTask

接口Future<V>表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。计算完成后只能使用get()方法来获取结果，如有必要，计算完成前可以阻塞此方法。取消则由cancel方法来执行，还提供了其他方法，以确定任务是正常完成还是被取消了。一旦计算完成，就不能再取消计算了。如果为了可取消性而使用Future但又不提供可用的结果，则可以声明Future<?>形式类型，并返回null作为底层任务的结果。

Future主要定义了5个方法：cancle(boolean myaInterruptIfRunning)

isCancelled()

isDone():如果任务已完成，则返回true,可能由于正常终止，异常或取消而完成，在所有这些情况中，此方法都返回true

V get()如有必要，等待计算完成，然后获取其结果

V get(long timeout,TimeUnit unit):如有必要，最多等待为使用计算完成所给定的时间之后，获取其结果（如果结果可用）

FutureTask类是Future 的一个实现，并实现了Runnable，所以可通过

Executor(线程池) 来执行。也可传递给Thread对象执行。

如果在主线程中需要执行比较耗时的操作时，但又不想阻塞主线程时，可以把这些作业交给

Future对象在后台完成，当主线程将来需要时，就可以通过Future对象获得后台作业的计算结果或者执行状态。Callable要采用ExecutorService的submit方法提交，返回的future对象可以取消任务。

threadPool.submit(callable<>)调用callable可返回值的线程，返回结果给future，

future.get()返回结果

CompletionService用于提交一组Callable任务，其take方法返回已完成的一个Callable任务对应的Future对象。

下面是一个示例：

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class FutureAndCallableTest {

    public static void main(String[] args)throws Exception {
        testSingleFutureAndCallable();
        testMultFutureAndCallable();
    }
    
    /**
    *测试只有一个线程一个任务的Future
    */
    public static void testSingleFutureAndCallable()throws Exception{
        ExecutorService service = Executors.newSingleThreadExecutor();
        
        Future<String> future = service.submit(new Callable<String>(){
            @Override
            public String call() throws Exception {
                Thread.sleep(3000);
                return "Hello";
            }
        });    
        
        System.out.println("等待拿到结果：");
        System.out.println(future.get());
        service.shutdown();
        
    }
    /**
     * 提交一组callable，谁先完成就拿谁的结果
     * @throws Exception
     */
    public static void testMultFutureAndCallable()throws Exception{
        //新建了一个固定线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        //CompletionService 可以将已完成任务与未完成的任务分离出来 ExecutorCompletionService此类将安排那些完成时提交的任务，把它们放置在可使用 take 访问的队列上
        CompletionService<String> completionService = new ExecutorCompletionService<String>(service);
        //加入10个输出字符串的任务，并使每个任务随机停留时间在3秒内
        for(int i=0;i<10;i++){
            final int num = i;
            completionService.submit(new Callable<String>(){
                @Override
                public String call() throws Exception {
                    Thread.sleep(new Random().nextInt(3000));
                    return "hello"+num;
                }
            });
        }
        //获取任务的结果
        for(int j=0;j<10;j++){
            
            Future<String> future =completionService.take();
            System.out.println(future.get());
        }
        //关闭线程池
        service.shutdown();
        
    }

}