java并发编程：Callable、Future和FutureTask

1.问题引入

     创建线程有2中方式：直接继承Thread和实现Runnable接口。但是这2种方式都有一个缺陷，那就是执行完任务之后无法获取执行结果。

     如果需要获取执行结果，就必须通过共享变量或者使用线程通信的方式来达到效果，但这样使用起来非常麻烦。

     所以，自从jdk1.5之后，就提供了Callable和Future，通过他们可以获得任务执行完毕之后得到任务的执行结果。

2.Callable和Runnable

     先说一下Runnable接口，在其中只声明了一个run（）方法

public interface Runnable 
{
    public abstract void run();
}

     由于run（）方法返回值为void类型，所以在执行完任务之后，无法返回任何结果。

     Callable位于java.util.concurrent包下，也是一个接口，在里面也是只声明了一个方法：

public interface Callable<V> 
{
    V call() throws Exception;
}

    可以看到，这是一个泛型接口，call（）返回的类型就是传递进来的泛型

    那么如何使用Callable呢？一般情况下需要配合ExecutorService，在ExecutorService接口中声明了若干个submit方法的重载版本

    <T> Future<T> submit(Callable<T> task);

    <T> Future<T> submit(Runnable task, T result);

    Future<?> submit(Runnable task);

      第一个submit方法里的参数类型就是Callable。一般我们使用第一和第三个方法

3.Future

     Future就是对具体的Runnable或者Callable任务的结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果

     Future位于java.util.concurrent包下：

public interface Future<V> 
{
    boolean cancel(boolean mayInterruptIfRunning);                //用来取消任务，参数表示是否能够取消正在执行却没有执行完成的任务 

    boolean isCancelled();                                       //用来表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回true

    boolean isDone();                                              //表示任务是否已经完成，如果任务完成则返回true

    V get() throws InterruptedException, ExecutionException;       //用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回

    V get(long timeout, TimeUnit unit)                                //获取执行结果，如果在指定时间内还没有取到结果，就直接返回null
        throws InterruptedException, ExecutionException, TimeoutException;
}

       简单地说，Future提供了3种功能：

       （1）中断任务    （2）判断任务是否完成    （3）获取任务执行结果

      因为Future只是一个接口，所以是无法直接用来创建对象使用的，因此有了下面的FutureTask

4.FutureTask

     先看一下FutureTask的声明

public class FutureTask<V> implements RunnableFuture<V> 

      FutureTask实现了RunnableFuture接口，我们看一下RunnableFuture接口的实现

public interface RunnableFuture<V> extends Runnable, Future<V> 
{
    void run();
}

       可以看出FutureTask实现了RunnableFuture接口，RunnableFuture接口继承了Runnable和Future接口，所以FutureTask既可以作为线程执行，又可以作为Future得到Callable的返回值

      FutureTask的构造器

    public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }

    public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
    }

      可以看出不论是使用Callable还是Runnable，最终都是转换为Callable

5.使用实例

     （1）使用Callable+Future获取执行结果

class Task implements Callable<Integer>
{
	@Override
	public Integer call() throws Exception 
	{
		System.out.println("sub thread is running");
		Thread.sleep(3000);
		int sum = 0;
		for(int i=1; i<100; i++)
			sum += i;
		return sum;
	}
	
}
public class TestFuture 
{	
	public static void main(String[] args) 
	{
		ExecutorService executorService = Executors.newCachedThreadPool();
		Task task = new Task();
		Future<Integer> result = executorService.submit(task);
		executorService.shutdown();
		
		try 
		{
			Thread.sleep(1000);
		}
		catch (InterruptedException e1) 
		{
			e1.printStackTrace();
		}
		try 
		{
			System.out.println(result.get());
		} 
		catch (InterruptedException e) 
		{
			e.printStackTrace();
		}
		catch (ExecutionException e) 
		{
			e.printStackTrace();
		}
}

           结果为：

sub thread is running
4950

     （2）使用Callable+FutureTask获取执行结果

	public static void main(String[] args) 
	{
		ExecutorService executorService = Executors.newCachedThreadPool();
		Task task = new Task();
		FutureTask<Integer> futureTask =new FutureTask<>(task);
		executorService.submit(futureTask);
		executorService.shutdown();
		
		try 
		{
			Thread.sleep(1000);
		}
		catch (InterruptedException e1) 
		{
			e1.printStackTrace();
		}
		try 
		{
			System.out.println(futureTask.get());
		} 
		catch (InterruptedException e) 
		{
			e.printStackTrace();
		}
		catch (ExecutionException e) 
		{
			e.printStackTrace();
		}
	}

         结果与上面完全相同