Java中的Runnable、Callable、Future、FutureTask的区别与示例

Java中存在Runnable、Callable、Future、FutureTask这几个与线程相关的类或者接口，在Java中也是比较重要的几个概念，我们通过下面的简单示例来了解一下它们的作用于区别。

Runnable

其中Runnable应该是我们最熟悉的接口，它只有一个run()函数，用于将耗时操作写在其中，该函数没有返回值。然后使用某个线程去执行该runnable即可实现多线程，Thread类在调用start()函数后就是执行的是Runnable的run()函数。Runnable的声明如下 

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

Callable

Callable与Runnable的功能大致相似，Callable中有一个call()函数，但是call()函数有返回值，而Runnable的run()函数不能将结果返回给客户程序。Callable的声明如下 :

public interface Callable<V> {

    V call() throws Exception;
}

可以看到，这是一个泛型接口，call()函数返回的类型就是客户程序传递进来的V类型。 Executor就是Runnable和Callable的调度容器，Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果、设置结果操作。get方法会阻塞，直到任务返回结果( Future简介 )。Future声明如下 :

public interface Future<T>
{
    V get() throws ...;
    V get(long timeout, TimeUnit unit) throws ...;
    void cancle(boolean mayInterrupt);
    boolean isCancelled();
    boolean isDone();
}

具体的实现类为java.util.concurrent.FutureTask<V>。

FutureTask

FutureTask则是一个RunnableFuture<V>，而RunnableFuture实现了Runnbale又实现了Futrue<V>这两个接口，

public class FutureTask<V> implements RunnableFuture<V>

   RunnableFuture

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

另外它还可以包装Runnable和Callable<V>， 由构造函数注入依赖。

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
  }

可以看到，Runnable注入会被Executors.callable()函数转换为Callable类型，即FutureTask最终都是执行Callable类型的任务。该适配函数的实现如下 ：

public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<T>(task, result);
    }

RunnableAdapter适配器

 static final class RunnableAdapter<T> implements Callable<T> {
    final Runnable task;
    final T result;
    RunnableAdapter(Runnable task, T result) {
      this.task = task;
      this.result = result;
    }
    public T call() {
      task.run();
      return result;
    }
  }

      由于FutureTask实现了Runnable，因此它既可以通过Thread包装来直接执行，也可以提交给ExecuteService来执行。并且还可以直接通过get()函数获取执行结果，该函数会阻塞，直到结果返回。

简单示例

package com.thread;

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;
import java.util.concurrent.FutureTask;


/**
 * Runnable和Callable的区别
 * Runnable没有返回值
 * Callable有返回值，值是通过Future获得的。
 * 
 * FutureTask是一个RunnableFuture<V>，而RunnableFuture实现了Runnbale又实现了Futrue<V>这两个接口，
  可以包装Runnable和Callable<V>， 由构造函数注入依赖。
 * @author hadoop
 *
 */
public class RunnableFutureTask {
    static  ExecutorService mExecutor = Executors.newSingleThreadExecutor();
    
    /**
     * 效率低下的斐波那契数列，耗时操作。这里没有引用外部共享域，fibc方法是线程安全的，不用考虑同步
     * @param num
     * @return
     */
    static int  fibc(int num){
    	if(num == 0){
    		return 0;
    	}
    	if(num == 1){
    		return 1;
    	}
    	return  fibc(num-1)+fibc(num-2);
    }
    
    /**
     * Runnable，无返回值
     */
    static void runnableDemo(){
    	 new Thread(
    	    new Runnable() {
				@Override
				public void run() {
					System.out.println("Runnable demo:" + fibc(20));  
				}
			} 
    	).start();
    }
    
    
    /**
     * 其中Runnable实现的是void run()方法，无返回值；
     * Callable实现的是V call()方法，并且可以返回执行结果。
     * 其中Runnable可以提交给Thread来包装下，直接启动一个线程来执行，而Callable则一般都是提交给ExecutorService来执行
     */
    static void futureDemo(){
    	 try {
    		 /**
    		  * 提交Runnable则没有返回值，futurn没有数据
    		  * 使用submit提交任务会返回Future对象，而使用execute没有返回值。
    		  * submit提交Runnable任务本质上也是转化为Callable去执行
    		  */
			Future<?>  result = mExecutor.submit(new Runnable() {
				@Override
				public void run() {
				   fibc(20);	  
				}
			});
			System.out.println("future result from runnable:" + result.get());
			
			
			
			/**
			 * 提交Callable,有返回值，future中能够获取返回值
			 */
			Future<Integer> result2 = mExecutor.submit(new Callable<Integer>(){
				@Override
				public Integer call() throws Exception {
					// TODO Auto-generated method stub
					return fibc(20);
				}
			});
			System.out.println("future result from  callable:" + result2.get());
			
			
			/**
			 * FutureTask是一个RunnableFuture<V>，而RunnableFuture实现了Runnbale又实现了Futrue<V>这两个接口
			 * 同时包装了Runnable和Callable<V>， 由构造函数注入依赖。
			 * Runnable注入会被Executors.callable()函数转换为Callable类型，即FutureTask最终都是执行Callable类型的任务
			 */
			FutureTask<Integer> futureTask = new FutureTask<Integer>(
					new Callable<Integer>() {
							@Override
							public Integer call() throws Exception {
								// TODO Auto-generated method stub
								return fibc(20);
							}
			});
			//提交futureTask
			mExecutor.submit(futureTask);
			System.out.println("future result from futureTask:" + futureTask.get());
			
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
            e.printStackTrace();
		}
    }
    
    
    public static void main(String[] args) {
		  runnableDemo();
		  futureDemo();
		  
		    System.out.println("已经开启所有的子线程");  
		    mExecutor.shutdown();  
	        System.out.println("shutdown()：启动一次顺序关闭，执行以前提交的任务，但不接受新任务。");  
	        while(true){  
	            if(mExecutor.isTerminated()){  
	                System.out.println("所有的子线程都结束了！");  
	                break;  
	            }  
	        }  
	}
}