netty中promise和future实例详解

netty promise和future详解

一、代码

为更好的解理netty中的promise，下面跑一下小程序。下面一段程序来源于：JAVA 拾遗 --Future 模式与 Promise 模式

package io.netty.example.echo;

import io.netty.util.concurrent.DefaultEventExecutorGroup;
import io.netty.util.concurrent.EventExecutorGroup;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.FutureListener;

import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;

/**
 * Created by arthur.dy.lee on 2019-10-20.
 */
public class NettyFutureDemo {

    public static void main(String[] args) throws InterruptedException {
        long l = System.currentTimeMillis();
        EventExecutorGroup group = new DefaultEventExecutorGroup(4);//创建执行线程池SingleThreadEventExecutor
        Future<Integer> f = group.submit(new Callable<Integer>() { //创建Callable
            @Override
            public Integer call() throws Exception {
                System.out.println("执行耗时操作...");
                timeConsumingOperation();
                return 100;
            }
        });
        f.addListener(new FutureListener<Object>() { //添加匿名监听者
            @Override
            public void operationComplete(Future<Object> objectFuture) throws Exception {
                System.out.println("计算结果:：" + objectFuture.get()); //promise.get获取集果
            }
        });
        System.out.println("主线程运算耗时:" + (System.currentTimeMillis() - l)+ "ms");
        new CountDownLatch(1).await();
    }

    static void timeConsumingOperation() {
        try {
            Thread.sleep(3000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

二、时序图

下面的时序图可点击看大图

三、调用过程

1. 创建线程池SingleThreadEventExecutor

EventExecutorGroup group = new DefaultEventExecutorGroup(4);创建4个线程：SingleThreadEventExecutor。以下是创建的关键代码。

children = new EventExecutor[nThreads];
powerOfTwo = isPowerOfTwo(children.length);
for (int i = 0; i < nThreads; i ++) {
    boolean success = false;
    try {
        children[i] = newChild(executor, maxPendingTasks, rejectedHandler, args);
        success = true;

protected EventExecutor newChild(Executor executor,  int maxPendingTasks,
                                 RejectedExecutionHandler rejectedExecutionHandler,
                                 Object... args) {
    assert args.length == 0;
    return new SingleThreadEventExecutor(executor, maxPendingTasks, rejectedExecutionHandler); 
}

2. 创建Callable匿名类

new Callable<Integer>() {
    @Override
    public Integer call() throws Exception {
        System.out.println("执行耗时操作...");
        timeConsumingOperation();
        return 100;
    }
}

3. submit提交Callable执行

Future f = group.submit(new Callable() {...

看时序图可知，submit主要是3个任务：创建DefaultPromise、创建RunnableFutureAdapter和执行Callable匿名类。

RunnableFutureAdapter其实就是一个future和Runnable的实现类，创建RunnableFutureAdapter后，返回的就是Future f。创建RunnableFutureAdapter时，将DefaultPromise和Callable传入RunnableFutureAdapter。

当使用f.addListener时，RunnableFutureAdapter就是一个future；当调用Runnable#run方法时，它就是一个task。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-n40alHRU-1571589124811)(https://live.staticflickr.com/65535/48929567948_95414081ba_b.jpg)]

执行Callable的过程：submit后，通过SingleThreadEventExecutor来执行，先将task(Callable)放到队列中，后startThread，doStartThread会启动一下新的线程，代码如下：

private void doStartThread() {
    assert thread == null;
    executor.execute(() -> {
        thread = Thread.currentThread();
        if (interrupted) {
            thread.interrupt();
        }

        boolean success = false;
        updateLastExecutionTime();
        try {
            SingleThreadEventExecutor.this.run(); // 执行任务
            success = true;

时序图中，22和23反了。run方法中，先取出任务task(RunnableFutureAdapter)

protected void run() {
    assert inEventLoop();
    do {
        Runnable task = takeTask();
        if (task != null) {
            task.run(); //RunnableFutureAdapter#run
            updateLastExecutionTime();
        }
    } while (!confirmShutdown());
}

RunnableFutureAdapter#run后运行任务Callable#run

@Override
public void run() {
    try {
        if (promise.setUncancellable()) {
            V result = task.call(); //Callable#run
            promise.setSuccess(result); //promise获取结果
        }
    } catch (Throwable e) {
        promise.setFailure(e);
    }
}

此时已完成Callable的调用

4. 添加监听者Listener

listener不需要等待主线程执行。当Callable执行完后，会通知到监听的listener类，对Callable的结果进行处理。

此处的Future