03-Netty中的Future接口

最新推荐文章于 2022-03-30 08:53:57 发布

惑边

最新推荐文章于 2022-03-30 08:53:57 发布

阅读量430

点赞数

分类专栏： Netty

本文链接：https://blog.csdn.net/my_momo_csdn/article/details/102724347

版权

Netty 专栏收录该内容

24 篇文章 1 订阅

订阅专栏

文章目录

Netty中的Future体系

Netty中的Future体系

Future体系在线程池部分有分析过，它代表了一个异步操作的结果，一个典型的子接口和实现是RunnableFuture接口和FutureTask。相关内容可以参考：Future接口
在Netty中有着大量的异步操作，在获取异步操作结果也需要使用到Future，不过对于Netty而言，JDK中的Future机制相对来说简单，为了更加方便的异步编程，Netty基于Future接口扩展了一些自己的接口，我们先看看有哪些接口体系。

一、Future

JDK中的Future接口是java.util.concurrent.Future，Netty中也有Future接口，全类名是io.netty.util.concurrent.Future，它继承自JDK中的Future接口，也是整个NettyFuture体系的顶层接口，对于的继承关系如下：

在这里插入图片描述

看的出来继承关系是比较复杂的，每一个类都去分析显然也比较困难，本文我们就先从接口开始，看看Netty的Future和它派生出来的子接口分别代表什么。

1.1 Future接口

1.1.1 JDK Future

参考文章[1]中我们分析了JUC包中的Future，它定义的方法不算多，我们看看Netty/Future有什么扩展。

//下面是JDK的Future
public interface Future<V> {
    /**
     * 1.尝试取消任务，如果任务已经完成或者被取消则会取消失败，也有可能因为其他原因取消失败，方法返回true表示取消成功，
     *  false表示取消失败，通常是因为任务已经开始了
     * 2.如果任务还未开始并且被取消成功，那么这个任务再也不会被执行
     * 3.如果任务已经开始，mayInterruptIfRunning参数决定执行该任务的线程是否需要中断任务,true表示正在执行任务的线程需要中断，false表示既然已经开始执行了，就执行完毕吧
     * 4.如果方法返回true，那么isDone和isCancelled也会返回true
     */
    boolean cancel(boolean mayInterruptIfRunning);

    //如果任务在完成之前被取消，返回true
    boolean isCancelled();

    //如果任务已经完成，返回true，这里的完成不仅仅是代表正常完成，也有可能是异常终止，取消，这些都会返回true
    boolean isDone();

    //阻塞获取异步执行的结果
    V get() throws InterruptedException, ExecutionException;

    //指定超时时间的get超时
    V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}

1.1.2 Netty Future

Netty的Future接口

/**
 * 异步操作结果接口
 */
@SuppressWarnings("ClassNameSameAsAncestorName")
public interface Future<V> extends java.util.concurrent.Future<V> {

    /**
     * 只有当IO操作成功结束是返回true，其余情况返回false
     */
    boolean isSuccess();

    /**
     * 当操作可以被cancel方法取消，该方法返回true，否则返回false
     */
    boolean isCancellable();

    /**
     * 如果IO操作失败，返回IO操作失败的原因
     */
    Throwable cause();

    /**
     * 添加监听器，监听器会在任务结束后被调用，如果任务已经结束，那么监听器会被立刻执行
     */
    Future<V> addListener(GenericFutureListener<? extends Future<? super V>> listener);

    /**
     * 移除第一个监听器
     */
    Future<V> removeListener(GenericFutureListener<? extends Future<? super V>> listener);

    /**
     * 同步等待Future，如果失败抛出异常，支持中断
     */
    Future<V> sync() throws InterruptedException;

    /**
     * 同步等待Future，如果失败抛出异常,不支持中断
     */
    Future<V> syncUninterruptibly();

    /**
     * 等待到任务结束，支持中断
     */
    Future<V> await() throws InterruptedException;

    /**
     * 等待到任务结束，不支持中断(注释写了会捕获中断异常，然后默默的丢弃掉)
     */
    Future<V> awaitUninterruptibly();

    /**
     * 支持超时参数的await，支持中断
     */
    boolean await(long timeout, TimeUnit unit) throws InterruptedException;

    /**
     * 支持超时参数的await，不支持中断
     */
    boolean awaitUninterruptibly(long timeout, TimeUnit unit);

    /**
     * 立刻返回结果，如果完成了就返回结果，没完成就返回null
     */
    V getNow();

    /**
     * 继承自JDKFuture的方法
     */
    @Override
    boolean cancel(boolean mayInterruptIfRunning);
}

由此我们看到Netty中的Future除了继承自JDK的Future之外，还定义了许多自己的方法，比如最重要的是添加监听器，这样就能在任务结束之后自动回调监听器中自己需要执行的逻辑。

1.2 Future派生子接口

1.2.1 Promise

Promise代表可写的Future，在Future接口中，我们只能对其进行“读”操作，获取结果，判断是否完成等，但是我们不能对其进行写操作。而Promise代表可写的Future，Promise增强了Future的功能，通过Promise可以为Future设置结果，比如成功或者失败原因等。

/**
 * 可写的Future对象
 */
public interface Promise<V> extends Future<V> {

    /**
     * 将Future设置为success，并通知所有监听者
     */
    Promise<V> setSuccess(V result);

    /**
     * 尝试将Future设置为success，并通知所有监听者,尝试成功返回true，失败则返回false
     */
    boolean trySuccess(V result);

    /**
     * 将Future设置为failure，并通知所有监听者
     */
    Promise<V> setFailure(Throwable cause);

    /**
     * listeners.
     * 将Future设置为failure，并通知所有监听者 ,尝试成功返回true，失败则返回false
     */
    boolean tryFailure(Throwable cause);

    /**
     * 将future设置为不能中断
     */
    boolean setUncancellable();
}

1.2.2 ChannelFuture

ChannelFuture是代表一个Channel异步IO操作的结果，自身自定义了1个主要方法，将Future关联的Channel对象返回

/**
 * Channel异步IO操作的结果，Netty中所有的IO操作都是异步的，IO操作会直接返回并且不保证最
 * 后能够成功完成，用户通过返回的ChannelFuture对象来获取结果。
 * The result of an asynchronous {@link Channel} I/O operation.
 *                                      +---------------------------+
 *                                      | 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      |
 *                                      +---------------------------+
 */
public interface ChannelFuture extends Future<Void> {

    /**
     * Returns a channel where the I/O operation associated with this future takes place.
     * <p>
     * 返回Future关联的IO操作对应的Channel通道
     */
    Channel channel();

    /**
     * 返回true表示ChannelFuture是void，此时不能调用下面的方法：addListener、addListeners、await、sync、syncUninterruptibly
     */
    boolean isVoid();
}

1.2.3 ChannelGroupFuture

ChannelGroupFuture代表一个ChannelGroup的IO执行结果

/**
 * ChannelGroupFuture代表一个ChannelGroup里面的IO操作的集合
 */
public interface ChannelGroupFuture extends Future<Void>, Iterable<ChannelFuture> {

    /**
     * 返回对应的ChannelGroup
     */
    ChannelGroup group();

    /**
     * 根据Channel，找到其对应的ChannelFuture
     */
    ChannelFuture find(Channel channel);


    @Override
    boolean isSuccess();

    @Override
    ChannelGroupException cause();

    /**
     * 是否部分成功
     */
    boolean isPartialSuccess();

    /**
     * 是否部分失败
     */
    boolean isPartialFailure();
 
}

1.2.4 ProgressiveFuture

ProgressiveFuture是用于代表一个操作进度的Future，本身没有定义任何方法，都是继承自Future

1.2.5 ScheduledFuture

ScheduledFuture用于代表一个预定的异步操作(scheduled asynchronous operation)的结果。

1.3 抽象实现类AbstractFuture

AbstractFuture是Future的一个抽象实现类，AbstractFuture没有实现什么方法，只实现了get()方法，方法内部还依赖很多其他的方法，比如：await()、cause()、getNow() ，这些都需要子类去实现。

/**
 * Abstract {@link Future} implementation which does not allow for cancellation.
 * Future的抽象实现，
 */
public abstract class AbstractFuture<V> implements Future<V> {

    @Override
    public V get() throws InterruptedException, ExecutionException {
        //1.等待任务完成
        await();
        //2.获取异常
        Throwable cause = cause();
        if (cause == null) {
            //3.没有异常则获取结果
            return getNow();
        }
        //4.有异常就抛出
        if (cause instanceof CancellationException) {
            throw (CancellationException) cause;
        }
        throw new ExecutionException(cause);
    }

    @Override
    public V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
        if (await(timeout, unit)) {
            Throwable cause = cause();
            if (cause == null) {
                return getNow();
            }
            if (cause instanceof CancellationException) {
                throw (CancellationException) cause;
            }
            throw new ExecutionException(cause);
        }
        throw new TimeoutException();
    }
}

二、小结

本文主要介绍了Netty中的Future接口，它继承自JDK的Future接口，并扩展了一些方法，主要是增加了对监听器的支持。
Netty的Future接口派生出了很多子接口，派生出的子接口自然具备Future这个基本的功能，除此之外，各自具备一些自身的接口特点，比如
Promise代表可写的Future，ChannelFuture代表Channel异步IO的结果，ChannelGroupFuture代表一个ChannelGroup的结果，ProgressiveFuture代表一个操作进度，ScheduledFuture代表预定操作的结果，具体不同的接口往下继续派生的接口和子类，我们在后面根据重要程序和使用情况慢慢分析，这也不是一篇文章足以涵盖的。

三、参考

[1] Future接口

惑边

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
03-Netty中的Future接口

文章目录Netty中的Future体系一、Future1.1 Future接口1.1.1 JDK Future1.1.2 Netty Future1.2 Future派生子接口1.2.1 Promise1.2.2 ChannelFuture1.2.3 ChannelGroupFuture1.2.4 ProgressiveFuture1.2.5 ScheduledFuture1.3 抽象实现类Abs...
复制链接

扫一扫

专栏目录