Netty：ChannelFuture

上一篇我们完成了对Channel的学习，这一篇让我们来学习一下ChannelFuture。

ChannelFuture的简介

ChannelFuture是Channel异步IO操作的结果。

Netty中的所有IO操作都是异步的。这意味着任何IO调用都将立即返回，而不能保证所请求的IO操作在调用结束时完成。相反，将返回一个带有ChannelFuture的实例，该实例将提供有关IO操作的结果或状态的信息。

ChannelFuture要么是未完成状态，要么是已完成状态。IO操作刚开始时，将创建一个新的Future对象。新的Future对象最初处于未完成的状态，因为IO操作尚未完成，所以既不会执行成功、执行失败，也不会取消执行。如果IO操作因为执行成功、执行失败或者执行取消导致操作完成，则将被标记为已完成的状态，并带有更多特定信息，例如失败原因。请注意，即使执行失败和取消执行也属于完成状态。

ChannelFuture提供了各种方法，可让您检查IO操作是否已完成，等待完成以及获取IO操作的结果。它还允许您添加ChannelFutureListener，以便在IO操作完成时得到通知。

Prefer addListener(GenericFutureListener) to await()

推荐使用addListener(GenericFutureListener)而不是await()，以便在完成IO操作并执行任何后续任务时得到通知。

addListener(GenericFutureListener)是非阻塞的。它只是将指定的ChannelFutureListener添加到ChannelFuture，并且与将来关联的IO操作完成时，IO线程将通知监听器。ChannelFutureListener完全不阻塞，因此可产生最佳的性能和资源利用率，但是如果不习惯事件驱动的编程，则实现顺序逻辑可能会比较棘手。

相反，await()是阻塞操作。一旦被调用，调用者线程将阻塞直到操作完成。使用await()实现顺序逻辑比较容易，但是调用者线程会不必要地阻塞直到完成IO操作为止，并且线程间通知的成本相对较高。此外，在特定情况下还可能出现死锁。 

Do not call await() inside ChannelHandler

ChannelHandler中的事件处理程序方法通常由IO线程调用，如果await()是由IO线程调用的事件处理程序方法调用的，则它正在等待的IO操作可能永远不会完成，因为await()会阻塞它正在等待的IO操作，这是一个死锁。

// BAD - NEVER DO THIS
   @Override
   public void channelRead(ChannelHandlerContext ctx, Object msg) {
       ChannelFuture future = ctx.channel().close();
       future.awaitUninterruptibly();
       // Perform post-closure operation
       // ...
   }

// GOOD
   @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
               // ...
           }
       });
   }

尽管有上述缺点，但是在某些情况下，调用await()更方便。在这种情况下，请确保不要在IO线程中调用await()。 否则，将引发BlockingOperationException来防止死锁。

 Do not confuse I/O timeout and await timeout 

使用await(long)，await(long，TimeUnit)，awaitUninterruptible(long)或awaitUninterruptible(long，TimeUnit)指定的timeout与IO超时根本不相关。 如果IO操作超时，则Future将被标记为“Completed with failure”，如上图所示。 例如，应通过特定于传输的选项配置连接超时：

// BAD - NEVER DO THIS
   Bootstrap b = ...;
   ChannelFuture f = b.connect(...);
   f.awaitUninterruptibly(10, TimeUnit.SECONDS);
   if (f.isCancelled()) {
       // Connection attempt cancelled by user
   } else if (!f.isSuccess()) {
       // You might get a NullPointerException here because the future
       // might not be completed yet.
       f.cause().printStackTrace();
   } else {
       // Connection established successfully
   }
  

   // GOOD
   Bootstrap b = ...;
   // Configure the connect timeout option.
   b.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 10000);
   ChannelFuture f = b.connect(...);
   f.awaitUninterruptibly();
  
   // Now we are sure the future is completed.
   assert f.isDone();
  
   if (f.isCancelled()) {
       // Connection attempt cancelled by user
   } else if (!f.isSuccess()) {
       f.cause().printStackTrace();
   } else {
       // Connection established successfully
   }

ChannelFuture的方法

ChannelFuture的方法并不多，可以简单的看一下。

channel()：返回ChannelFuture关联的Channel；

addListener()：将指定的listener添加到Future。Future完成时，将通知指定的listener。如果Future已经完成，则立即通知指定的listener；

addListeners()：和上述方法一样，只不过此方法可以新增一系列的listener；

removeListener()：从Future中删除第一次出现的指定listener。完成Future时，不再通知指定的listener。如果指定的listener与此Future没有关联，则此方法不执行任何操作并以静默方式返回。

removeListeners()：和上述方法一样，只不过此方法可以移除一系列的listener；

sync()：等待Future直到其完成，如果这个Future失败，则抛出失败原因；

syncUninterruptibly()：不会被中断的sync()；

await()：等待Future完成；

awaitUninterruptibly()：不会被中断的await ()；

isVoid()：如果此ChannelFuture是void的Future，则返回true，因此不允许调用以下任何方法：

addListener(GenericFutureListener)

addListeners(GenericFutureListener[])

await()

await(long, TimeUnit) ()}

await(long) ()}

awaitUninterruptibly()

sync()

syncUninterruptibly()

为什么使用ChannelFuture？

从JDK1.5之后，J.U.C提供了Future类，它代表着异步计算的结果。Future类提供了如下方法：

方法	方法说明
boolean cancel(boolean mayInterruptIfRunning)	尝试取消执行此任务。如果任务已经完成，已经被取消或由于某些其他原因而无法取消，则此尝试将失败。如果成功，并且在调用cancel时此任务尚未启动，则该任务永远不要运行。如果任务已经启动，则mayInterruptIfRunning参数确定是否应中断执行该任务的线程以尝试停止该任务。 此方法返回后，对isDone的后续调用将始终返回true。如果此方法返回true，则随后对isCancelled的调用将始终返回true。
boolean isCancelled()	如果此任务在正常完成之前被取消，则返回true。
boolean isDone()	如果此任务完成，则返回true。完成可能是由于正常终止，异常或取消引起的，在所有这些情况下，此方法都将返回true。
V get()	必要时等待计算完成，然后检索其结果。
V get(long timeout, TimeUnit unit)	必要时最多等待给定时间以完成计算，然后检索其结果。

从这些方法中，可以看出Future类存在2大问题： 

1、isDone()的定义模糊不清，不管是失败、异常还是成功，isDone()返回的都是true；

2、get()获取结果的方式是阻塞等待的方式。 

所以Netty中的Future对JDK中的Future做了扩展，而ChannelFuture继承Future，固然也能充分利用这个扩展出的新特性。新特性主要体现在如下两方面：

1、引入isSuccess()来表示执行成功，引入cause()来表示执行失败的原因；

2、引入Future-Listener机制来替代主动get()阻塞等待的机制。 

对于第1点，可以回到简介部分，该图表清晰的描述了这个异步调用的状态变化。当异步结果未完成时，isDone()、isSuccess()、isCancelled()均为false，同时cause()返回null，若是完成成功，则isDone()、isSuccess()均为true，若是完成失败，则isDone()为true，cause()返回not-null，若是取消完成，则

isDone()、isCancelled()均为true。可以看到新引入的特性可以很清晰的表示常用的状态。

对于第2点，Future-Listener机制本质上就是一种观察者模式，Netty中的Future通过提供addListener/addListeners方法来实现对Future执行结果的监听，一旦Future执行完成，就会触发GenericFutureListener的operationComplete方法，在该方法中就可以获取Future的执行结果，这种方式比起直接get()，能有效提升Netty的吞吐量。 

至此，我们就学习完了ChannelFuture，最后总结一下：

1、Netty中的所有IO操作都是异步的。这意味着任何IO调用都将立即返回，而不能保证所请求的IO操作在调用结束时完成。ChannelFuture是Channel异步IO操作的结果；

2、ChannelFuture或者说是Future，通过引入新的特性解决了原生JDK中Future对于状态模糊不清及阻塞等待获取结果的方式，这个新特性就是引入isSuccess()、cause()方法，同时通过Future-Listener回调机制解决不知道何时能获取到Future结果的问题。