netty 之 异步处理双子星io.netty.util.concurrent.Future与io.netty.util.concurrent.Promise

一、JDK的Future

从这个类的注释中,我们可以了解到:

Future 类就是代表了异步计算的结果,这个接口的主要方法就是检查计算是否已完成,等待计算,然后返回计算结果。

当计算完成后,结果只能通过get方法返回;如果有必要会堵塞直到它计算完成。

可以通过cancel方法取消。增加的方法来判断任务是否正常完成或者被取消。一旦计算已经完成,计算不能被取消。

如果你想要使用Future 来取消,但是不提供一个可用的结果,你可以声明Futrue 的类型,但会返回null 作为一个基本任务的结果。

FutureTask 类是Futrue类的一个实现类,实现了Runnable接口,可以被Executor 执行。

二、JDK的FutureTask

  • 一个可取消的异步计算,这个类提供了对Future 的基本实现。有对计算的启动和取消方法,查询计算是否已完成,以及返回计算的结果。
  • 计算的结果只有在计算已完成后才能返回,如果计算没有完成,get方法会堵塞。一旦计算已经完成,计算不能被重启或取消。(除非计算是被runAndReset方法调用)
  • 可以看到这个类中有表示计算执行的状态
    private volatile int state;
    private static final int NEW          = 0;
    private static final int COMPLETING   = 1;
    private static final int NORMAL       = 2;
    private static final int EXCEPTIONAL  = 3;
    private static final int CANCELLED    = 4;
    private static final int INTERRUPTING = 5;
    private static final int INTERRUPTED  = 6;
  • 在判断当前计算是否已完成等状态时,都是通过这个字段来进行判断。

三、Netty的Future

1、说明

Netty的【Future】扩展了【java.util.concurrent.Future】:

  • 保留jdk Future的若干阻塞行为的接口
  • 同时增加了【listener类型的接口】,通过监听器可以让异步执行更加有效率(当异步执行有结果时进行回调)

2、Netty的Future继承体系与方法如下

四、Netty的io.netty.channel.ChannelFuture

netty的【ChannelFuture】又扩展了netty的【Future】

  • 提供和一个Channel进行绑定(通过ChannelFuture的channel方法可以获取对应的Channel对象)。
  • ChannelFuture的大部分接口都是Override的io.netty.channel.ChannelFuture
    • ①将类型具化成ChannelFuture
    • ②将参数GenericFutureListener的范型具化成   <? extends Future<? super Void>>,其中<? super Void>表示了一种没有返回值的异步调用:

4.1 ChannelFuture的状态

ChannelFuture有两种状态:未完成(uncompleted)和完成(completed).
当令Channel开始一个I/O操作时,会创建一个新的ChannelFuture去异步完成操作.
被创建时的ChannelFuture处于uncompleted状态(非失败,非成功,非取消);一旦ChannelFuture完成I/O操作,ChannelFuture将处于completed状态,结果可能有三种:

  1. 操作成功
  2. 操作失败
  3. 操作被取消(I/O操作被主动终止)
    需要关注ChannelFuture的其它属性来获取异常信息。

下图是 Netty API 中提供的ChannelFuture状态迁移图:

                                      +---------------------------+
                                      | Completed successfully    |
                                      +---------------------------+
                                 +---->      isDone() = true      |
 +--------------------------+    |    |   isSuccess() = true      |
 |        Uncompleted       |    |    +===========================+
 +--------------------------+    |    | Completed with failure    |
 |      isDone() = false    |    |    +---------------------------+
 |   isSuccess() = false    |----+---->      isDone() = true      |
 | isCancelled() = false    |    |    |       cause() = non-null  |
 |       cause() = null     |    |    +===========================+
 +--------------------------+    |    | Completed by cancellation |
                                 |    +---------------------------+
                                 +---->      isDone() = true      |
                                      | isCancelled() = true      |
                                      +---------------------------+

4.2 ChannelFutureListener监听接口

ChannelFuture的get()方法获取异步操作的结果,但是切记一定要设置超时时间
Netty建议通过ChannelFutureListener接口执行异步操作结束后的回调

示例代码:

 @Override
 public void channelRead(ChannelHandlerContext ctx, Object msg) {
     ChannelFuture future = ctx.channel().close();
     future.addListener(new ChannelFutureListener() {
         public void operationComplete(ChannelFuture future) {
             // Perform post-closure operation
             // ...
         }
     });
 }

 另外,ChannelFuture允许添加一个或多个(移除一个或多个)ChannelFutureListener监听接口,方法名:addListener(), addListeners(), removeListener(), removeListeners()

五、Netty的Promise

1、说明

netty的【Promise】也扩展了netty的【Future】

  • 表示一种可写的Future:可以自定义设置异步执行的结果

 六、Netty的ChannelPromise

1、说明

netty的【ChannelPromise】也扩展了【Promise】、【ChannelFuture】

  • 绑定了Channel
  • 可以写异步执行结果
  • 具备【listener】功能

大部分方法都是Override父接口的方法:

  • 返回值声明成了具化的ChannelPromise类型
  • 参数GenericFutureListener的范型声明成了具化的:<? extends Future<? super Void>>

2、实现

DefaultChannelPromise是ChannelPromise的实现类,是实际运行时的Promise实例。

  • 继承体系中,DefaultChannelPromise与DefaultPromise分别负责对ChannelPromise的接口以及Promise的接口进行实现:
    • 比如:DefaultPromise中的对addListener方法的实现:
    @Override
    public Promise<V> addListener(GenericFutureListener<? extends Future<? super V>> listener) {
        checkNotNull(listener, "listener");

        synchronized (this) {
            addListener0(listener);
        }

        if (isDone()) {
            notifyListeners();
        }

        return this;
    }
    private void addListener0(GenericFutureListener<? extends Future<? super V>> listener) {
        if (listeners == null) {
            listeners = listener;
        } else if (listeners instanceof DefaultFutureListeners) {
            ((DefaultFutureListeners) listeners).add(listener);
        } else {
            listeners = new DefaultFutureListeners((GenericFutureListener<?>) listeners, listener);
        }
    }
    private void notifyListeners() {
        EventExecutor executor = executor();
        if (executor.inEventLoop()) {
            final InternalThreadLocalMap threadLocals = InternalThreadLocalMap.get();
            final int stackDepth = threadLocals.futureListenerStackDepth();
            if (stackDepth < MAX_LISTENER_STACK_DEPTH) {
                threadLocals.setFutureListenerStackDepth(stackDepth + 1);
                try {
                    notifyListenersNow();
                } finally {
                    threadLocals.setFutureListenerStackDepth(stackDepth);
                }
                return;
            }
        }

        safeExecute(executor, new Runnable() {
            @Override
            public void run() {
                notifyListenersNow();
            }
        });
    }
  • 可见,addListener方法中会先判断异步任务执行的状态isDone,如果异步任务执行完成就立即通知监听者,否则,加入监听者队列
  • 通知监听者就是找一个线程来执行调用监听者的回调函数
©️2020 CSDN 皮肤主题: Age of Ai 设计师:meimeiellie 返回首页