Netty源码解析-Future与Promise

public interface Future {
    // 取消任务
    boolean cancel(boolean mayInterruptIfRunning);
    // 任务是否被取消
    boolean isCancelled();
    
    // 任务是否已完成
    boolean isDone();
    // 获取结果集
    V get() throws InterruptedException, ExecutionException;
    // 在指定时间获取结果集
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

总结：根据上文中的示例，我们在将callable任务提交给ExecutorService后，立即就获取一个Future的结果集，当前主线程不必阻塞等待执行。

但是，当我们调用future.get()方法时，发生了阻塞，一直阻塞到方法执行完成，这里是不太符合我们的预期的。

当然，我们也可以使用另外一种方式，

while (!f.isDone()) {
   // sleep(100);
}
// 获取执行结果
System.out.println(f.get());

不断通过轮询来判断future任务是否已经执行完成。

但是这种方案缺点显而易见，就是主线程一直在执行状态（如果没有sleep的话），CPU消耗过高，那么有没有更好的方案呢？

    在JDK8中，提供了CompletableFuture方案，该方案真正的实现了异步调用，我们不必要阻塞获取结果集，或者不断轮询是否任务已经执行完成，而是通过注册回调函数的方案来实现结果集的获取。

public class SimplePromiseDemo {

    public static void main(String[] args) throws Throwable, ExecutionException {
        // 两个线程的线程池
        ExecutorService executor = Executors.newFixedThreadPool(1);
        //jdk1.8之前的实现方式
        CompletableFuture future = CompletableFuture.supplyAsync(new Supplier() {
            @Override
            public String get() {
                System.out.println("begin...");
                try {
                    //模拟耗时操作
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("end...");
                return "job executed ";
            }
        }, executor);

        //注册future执行成功后的回调函数
        future.thenAccept(e -> System.out.println(e));
        System.out.println("main thread end...");
    }
}

// 打印结果
begin...
// 主线程直接结束，阻塞任务的执行没有影响到主线程
main thread end...
// 2秒后打印出来，
end...
job executed 

总结：结果对比还是比较明显的，在CompletableFuture这种注册回调函数的异步调用方案下，主线程的方法执行没有被callable任务所阻塞，在任务执行完成后，主动执行了future.thenAccept中注册的任务。

这种才是真正的异步执行。

    作为Netty而言，并没有使用CompletableFuture的方案，而是自己实现了一套异步执行方案。

    我们先来看一下示例代码：

public class NettyPromiseTest {
    public static void main(String[] args) throws Throwable {
        // 使用Netty自定义的线程池组
        EventExecutorGroup group = new DefaultEventExecutorGroup(1);
        Future f = group.submit(new Callable() {

            @Override
            public String call() {
                System.out.println("begin...");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("end...");
                return "job executed";
            }
        });

        //注册监听，也就是上面的成功回调方法
        f.addListener(new FutureListener() {
            @Override
            public void operationComplete(Future f) throws Exception {
                System.out.println(f.get());
            }
        });

        System.out.println("main thread end...");
    }
}

// 打印结果如下：
begin...
// 没有阻塞，main线程直接结束
main thread end...
    
// 2秒后打印出来
end...
job executed

总结：Netty提供的这种异步方案，与上面2中的CompletableFuture比较相似，都是方法调用后返回一个Future，future注册一个回调函数，用于方法完成后的回调。

这些均不影响主线程的后续方法操作。

    Netty提供的这种异步策略，还是比较适合在我们实际的工作中的使用的，那它是怎么实现的呢？怎么完成从同步调用到异步调用的转换的呢？我们来看下。

public interface Future extends java.util.concurrent.Future {
 
    // 以下是抽取的重要的方法
    
    // 任务执行是否成功
    boolean isSuccess();
    // 添加监听方法
    Future addListener(GenericFutureListener