Netty--Future和Promise

最新推荐文章于 2024-05-21 12:10:22 发布

demon7552003

最新推荐文章于 2024-05-21 12:10:22 发布

阅读量372

点赞数

CC 4.0 BY-SA版权

分类专栏： # Netty 文章标签： Netty Future Promise

本文链接：https://blog.csdn.net/demon7552003/article/details/100845628

Netty 专栏收录该内容

13 篇文章

订阅专栏

本文详细介绍了Netty中Future与Promise的概念及其与JDK Future的区别。涵盖了Future的监听器管理、同步与异步等待方法，以及ChannelFuture和Promise的特性。通过源码分析，揭示了AbstractFuture、CompleteFuture和DefaultPromise的实现机制。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

概述

Future代表了异步操作的结果，Netty的Future对JDK的Future进行了扩展。

JDK.Future

仅定义了是否完成以及是否取消的状态判断以及get方法。

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}

Netty.Future

增加了：

结果状态
监听器管理
sync
await


public interface Future<V> extends java.util.concurrent.Future<V> {
    //status
    boolean isSuccess();
    boolean isCancellable();
    Throwable cause();

    //listener
    Future<V> addListener(GenericFutureListener<? extends Future<? super V>> listener);
    Future<V> addListeners(GenericFutureListener<? extends Future<? super V>>... listeners);
    Future<V> removeListener(GenericFutureListener<? extends Future<? super V>> listener);
    Future<V> removeListeners(GenericFutureListener<? extends Future<? super V>>... listeners);

    //sync
    Future<V> sync() throws InterruptedException;
    Future<V> syncUninterruptibly();

    //await
    Future<V> await() throws InterruptedException;
    Future<V> awaitUninterruptibly();
    boolean await(long timeout, TimeUnit unit) throws InterruptedException;
    boolean await(long timeoutMillis) throws InterruptedException;
    boolean awaitUninterruptibly(long timeout, TimeUnit unit);
    boolean awaitUninterruptibly(long timeoutMillis);
    V getNow();


    @Override
    boolean cancel(boolean mayInterruptIfRunning);
}

ChannelFuture

增加了相关channel信息。

状态信息：

public interface ChannelFuture extends Future<Void> {
    Channel channel();
    boolean isVoid();
}

Promise

Promise相对Future增加了设置状态的方法。


public interface Promise<V> extends Future<V> {
    //设置操作状态方法
    Promise<V> setSuccess(V result);
    boolean trySuccess(V result);
    Promise<V> setFailure(Throwable cause);
    boolean tryFailure(Throwable cause);
    boolean setUncancellable();

    @Override
    Promise<V> addListener(GenericFutureListener<? extends Future<? super V>> listener);

    @Override
    Promise<V> addListeners(GenericFutureListener<? extends Future<? super V>>... listeners);

    @Override
    Promise<V> removeListener(GenericFutureListener<? extends Future<? super V>> listener);

    @Override
    Promise<V> removeListeners(GenericFutureListener<? extends Future<? super V>>... listeners);

    @Override
    Promise<V> await() throws InterruptedException;

    @Override
    Promise<V> awaitUninterruptibly();

    @Override
    Promise<V> sync() throws InterruptedException;

    @Override
    Promise<V> syncUninterruptibly();
}

继承关系

源码分析

AbstractFuture<V>

get()方法调用await()方法。

public abstract class AbstractFuture<V> implements Future<V> {

    @Override
    public V get() throws InterruptedException, ExecutionException {
        await();

        Throwable cause = cause();
        if (cause == null) {
            return getNow();
        }
        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();
    }
}

CompleteFuture<V>

代表一个Future已经完成。

内部包含一个EventExecutor，用于注册事件监听器

public abstract class CompleteFuture<V> extends AbstractFuture<V> {

    private final EventExecutor executor;

    protected CompleteFuture(EventExecutor executor) {
        this.executor = executor;
    }

    @Override
    public Future<V> addListener(GenericFutureListener<? extends Future<? super V>> listener) {
        if (listener == null) {
            throw new NullPointerException("listener");
        }
        DefaultPromise.notifyListener(executor(), this, listener);
        return this;
    }

    @Override
    public Future<V> addListeners(GenericFutureListener<? extends Future<? super V>>... listeners) {
        if (listeners == null) {
            throw new NullPointerException("listeners");
        }
        for (GenericFutureListener<? extends Future<? super V>> l: listeners) {
            if (l == null) {
                break;
            }
            DefaultPromise.notifyListener(executor(), this, l);
        }
        return this;
    }
}

DefaultPromise<V>

设置状态内部使用了一个AtomicReferenceFieldUpdater

    private static final AtomicReferenceFieldUpdater<DefaultPromise, Object> RESULT_UPDATER =
            AtomicReferenceFieldUpdater.newUpdater(DefaultPromise.class, Object.class, "result");



private boolean setValue0(Object objResult) {
        if (RESULT_UPDATER.compareAndSet(this, null, objResult) ||
            RESULT_UPDATER.compareAndSet(this, UNCANCELLABLE, objResult)) {
            if (checkNotifyWaiters()) {
                notifyListeners();
            }
            return true;
        }
        return false;
    }