Future设计模式及ExecutorService中的submit提交

Future设计模式提供一种异步执行方式。提供这样一个场景，我们进行一个查询调用，该调用耗时时间长，因此当前线程不得不一直阻塞，直到拿到结果。这种情况下，就可以使用异步执行的方式，它会在进行调用时直接返回一个“凭证”，当前线程可以在后续某个时刻通过该“凭证”拿到查询结果。

一、Future设计模式实现

                                   图1.1 Future设计模式UML图

1.1 接口定义

为实现异步执行，我们需要将任务，任务结果解耦合。这至少需要三个部分，简单地，我们定义三个接口Future、Callable和FutureService来完成这一过程。

1.1.1 Future接口

Future提供获取执行结果和判断任务是否完成的两个接口，实际上它的实现类是对执行结果的一种封装。

public interface Future<T> {

    //返回计算结果
    T get() throws InterruptedException;

    //任务是否已经执行完成
    void finished(T result);

}

1.1.2 Callable接口

Callable主要提供给调用者实现计算逻辑，并返回最终的计算结果。该接口实际作用与Runnable类似，都是为那些其实例可能被另一个线程执行的类设计，是对任务的一种封装。但是Runnable不会返回结果，并且无法抛出经过检查的异常。

public interface Callable<T> {

    T call() throws Exception;

}

1.1.3 FutureService接口

FutureService主要用于提交任务，它对Future和Callable进行耦合，将执行结果赋予Future，否则任务和结果就无法产生联系。这里提供两种方式，一种是Callable，另一种是Runnable提交，实际上区别不大。

public interface FutureService<T> {

    //提交Runnable任务，则Future.get返回null
    Future<?> submit(Runnable runnable);

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

}

1.2 程序实现

1.2.1 FutureIml

FutureIml实现了接收任务执行结果的方法和任务结果提取的方法，在get结果时，若任务还未执行结束，该方法陷入阻塞(可比较producer/consumer的实现)。

public class FutureIml<T> implements Future<T> {

    private T result;

    private boolean isDone = false;

    private ReentrantLock lock = new ReentrantLock();

    private Condition condition = lock.newCondition();

    @Override
    public T get() throws InterruptedException {
        lock.lock();
        try{
            while (!isDone){
                condition.await();
            }
            return result;
        }finally {
            lock.unlock();
        }
    }

    @Override
    public void finished(T result) {
        lock.lock();
        try {
            this.result = result;
            this.isDone = true;
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }
}

1.2.2 FutureServiceIml

FutureServiceIml实现了对任务和结果的联系，可以看到，这种异步的实现是基于多线程的，另起一个新线程执行任务，并在任务结束时将结果传给Future。

public class FutureServiceIml<T> implements FutureService<T>{

    private final static String PRIFIX = "FUTURE-";

    private AtomicInteger integer = new AtomicInteger();

    private String getName(){
        return PRIFIX+integer.getAndIncrement();
    }
    @Override
    public Future<?> submit(Runnable runnable) {
        final FutureIml<Void> future = new FutureIml<>();
        new Thread(()->{
            runnable.run();
            future.finished(null);
        }, getName()).start();
        return future;
    }

    @Override
    public Future<T> submit(Callable<T> callable) {
        final FutureIml<T> future = new FutureIml<>();
        new Thread(()->{
            try {
                T result = callable.call();
                future.finished(result);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, getName()).start();
        return future;
    }
}

测试结果：

public class FutureTest {
    public static void main(String[] args) throws InterruptedException {
        FutureService service = new FutureServiceIml();
        Future future = service.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                return getString();
            }
        });

        System.out.println("Not blocked");

        System.out.println(future.get());
    }

    public static String getString() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        return "FINISHED";
    }
}

1.2.3 增加回调机制

Future很明显存在一个弊端，即get方法会阻塞。这就会造成当调用submit后，立刻调用get，则该阻塞与不使用Future模式的情况几乎相同了。这里的解决办法是回调机制，它可以让调用者不再进行显示地通过get方式获得数据而导致阻塞。

Future<T> submit(Callable<T> callable, Callback<T> callback);

我们将回调接口在任务提交时作为参数注入，这个Callback(JDK1.8)主要用来接受并处理任务的计算结果，当提交的任务执行完成之后，会将结果传递给Callback接口进行进一步的执行，这样在提交任务之后不再会因为通过get方法获得结果而陷入阻塞。

二、ExexecutorService中的submit

和们实现的简单的Future模式一样，ExecutorService中也包含三个部分，并且它是在线程池并发框架下应用的，因此还对Runnable接口进行了适配。

2.1 Callable与Future

Callable对任务进行了封装，但Future提供了更丰富的细节，除了可以从中拿到执行结果外，还可以实现对任务的控制部分控制(取消任务)。

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

public interface Future<V> {

    boolean cancel(boolean mayInterruptIfRunning);

    boolean isCancelled();

    boolean isDone();

    V get() throws InterruptedException, ExecutionException;

    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

2.2 适配器

Callable和Runnable类似，是为那些其实例可能被另一个线程执行的类设计，是对任务的封装。而线程只能接收Runnable任务，在线程池中最终的任务提交接口，execute方法只接收Runnable任务，因此我们需要兼顾Runnable、Callable和Future。

在我们自己的实现中，Callable被放在run方法下运行。在线程池中提供了更严谨的设计，它使用了两个适配器RunnableFuture和RunnableAdapter。

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

RunnableFuture是对Runnable接口和Future接口的适配，表示可以被控制状态的Runnable。通过实现这个接口，使得异步任务也可以通过excute方法提交。

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;
	}
}

RunnableAdapter是对Runnable和Callalbe的适配，实现了Callable接口，并聚合了Runnable对象。这个实现的主要功能是将Runnable转化为可以异步执行的任务，但这种方式Runnable也并不会给出任务执行结果，result值是使用者传入的。(这里将Callable与Runnable进行适配，当然不用适配也可以做到异步执行，但是需要新的类实现该功能，因此很没必要)。

2.3 FutureTask

我们已经了解了Callable、Future以及适配器，现在需要一个类似FutureService，对任务与结果进行整理，这就是FutureTask的主要工作。FutureTask实现了RunnableFuture接口，当execute方法提交该异步任务时，最终执行的是FutureTask类中的run方法。

public void run() {
	if (state != NEW ||
	     !UNSAFE.compareAndSwapObject(this, runnerOffset, null, Thread.currentThread()))
	     return;
	try {
		Callable<V> c = callable;
		if (c != null && state == NEW) {
			V result;
			boolean ran;
			try {
				result = c.call();
				ran = true;
			} catch (Throwable ex) {
				result = null;
				ran = false;
				setException(ex);
			}
			if (ran)
				set(result);
		}
	} finally {
		//在状态设置之前，runner必须为非null，以防止对run（）的并发调用
		runner = null;

		//为防止泄漏中断，必须在清空运行程序后重新读取状态
		int s = state;
		if (s >= INTERRUPTING)
			handlePossibleCancellationInterrupt(s);
	}
}

run方法中的工作与我们自实现的方法类似，主要是在run方法中执行call方法，并把执行结果交给Future。除此之外FutureTask还有一些需要关注的点。

private Callable<V> callable;
private Object outcome;
private volatile Thread runner;
private volatile WaitNode waiters;

这四个域分别是任务，结果，执行线程和一个链表。这个WaitNode是用于在多个线程get结果被阻塞时，用于保存这些阻塞的线程，类中还有具体的阻塞唤醒方法，不做赘述。

2.4 整体执行过程

整体执行过程从ExecutorService的submit方法看，它将要执行的异步任务进一步封装进实现了Runnable接口的FutureTask中，使之能被excute提交。通过excete提交后将Future返回，通过Future拿取执行结果。

使用线程池本身就是异步的，但是Runnable接口不能返回结果，通过Future设计模式，也就曲线救国了。

public <T> Future<T> submit(Callable<T> task) {
	if (task == null) throw new NullPointerException();
	RunnableFuture<T> ftask = newTaskFor(task);
	execute(ftask);
	return ftask;
}

protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
	return new FutureTask<T>(callable);
}

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