netty中的future和promise源码分析（二）

最新推荐文章于 2023-12-20 15:16:11 发布

weixin_34007291

最新推荐文章于 2023-12-20 15:16:11 发布

阅读量233

点赞数

文章标签： netty

原文链接：https://segmentfault.com/a/1190000013016083

版权

前面一篇netty中的future和promise源码分析（一）中对future进行了重点分析，接下来讲一讲promise.
promise是可写的future,从future的分析中可以发现在其中没有写操作的接口，netty特意使promise扩展了future,可以对异步操作结果进行设置。

(一)defaultpromise

包含的字段

//原子保存异步操作结果
private static final AtomicReferenceFieldUpdater<DefaultPromise, Object> RESULT_UPDATER =
AtomicReferenceFieldUpdater.newUpdater(DefaultPromise.class, Object.class, "result");
//异步操作结果
private volatile Object result;
private final EventExecutor executor;

操作结果通知

为了能够支持异步地获取操作结果，netty中用通知的方式来对后续的listener中的操作，操作结果等进行控制。通知的前提包括success,fail,cancel三种状态。

success状态:setsuccess()方法

第一步：异步操作结束调用setSuccess(V result)或trySuccess(V result)
方法，将操作结果当做参数传入，来通知可以对结果进行使用。

  public Promise<V> setSuccess(V result) {
   if (setSuccess0(result)) {
   //触发listener中的operationcomplete()方法
       notifyListeners();
       return this;
   }
   throw new IllegalStateException("complete already: " + this);
  }

第二步：首先调用setsuccess0()方法对result变量进行保存，如果保存成功则通过notifyListeners()触发listener中的operationcomplete()方法.（此处先不对notifylisteners()方法进行分析，见下文）

  #setsuccess0()方法：
  private boolean setSuccess0(V result) {
   return setValue0(result == null ? SUCCESS : result);
  }

  #setvalue0()方法：
  private boolean setValue0(Object objResult) {
   if (RESULT_UPDATER.compareAndSet(this, null, objResult) ||
       RESULT_UPDATER.compareAndSet(this, UNCANCELLABLE, objResult)) {
       checkNotifyWaiters();
       return true;
   }
   return false;
   }

注意：在success状态下保存结果时，如果result(异步操作结果)为null,则将promise内部的result设置为常量SUCCESS。再者，在promise的result中，只允许保存一次，所以netty采用cas保证结果只保存一遍，若结果保存出错返回false.

  #SUCCESS常量
  private static final Signal SUCCESS = Signal.valueOf(DefaultPromise.class.getName() + ".SUCCESS");

第三步：保存完结果后，通知所有同步等待异步操作结果的线程。
```
  private synchronized void checkNotifyWaiters() {
   if (waiters > 0) {
       notifyAll();
   }
  } 
```
2.success状态:trysuccess()方法

trysuccess()方法与setsuccess()方法大同小异，只不过在保存结果出错的时候，返回false,而setsuccess()抛出一个异常信息。
```
public boolean trySuccess(V result) {
   if (setSuccess0(result)) {
       notifyListeners();
       return true;
   }
   return false;
}
```
3.fail状态：

fail状态下通知机制和success几乎相同，区别在于保存异步操作结果的时候，fail状态保存的是使用CauseHolder进行封装的异常信息对象。
```
private boolean setFailure0(Throwable cause) {
   return setValue0(new CauseHolder(checkNotNull(cause, "cause")));
}
```
4.cancel状态：
cancel状态，表示异步操作的时候，对promise对象进行了cancel操作。
```
public boolean cancel(boolean mayInterruptIfRunning) {
   if (RESULT_UPDATER.compareAndSet(this, null, CANCELLATION_CAUSE_HOLDER)) {
       checkNotifyWaiters();
       notifyListeners();
       return true;
   }
   return false;
}
```
同样的，cancel后也和success和fail一样，对result进行了设置。在success的时候，允许初始值为null和UNCANCELLABLE常量（表示不允许cancel），在cancel状态只允许为null.
```
   # CANCELLATION_CAUSE_HOLDER
  //封装了CancellationException异常。
 private static final CauseHolder CANCELLATION_CAUSE_HOLDER = new CauseHolder(ThrowableUtil.unknownStackTrace(
new CancellationException(), DefaultPromise.class, "cancel(...)"));
```
5.操作结果通知总结：

首先，通过调用setsuccess()等方法，启动通知机制；
然后，将异步操作结果进行保存，仅允许保存一次，否则会返回false.
保存好信息后，触发listener中的操作，还会通知所有同步等待异步操作结果的线程。

添加监听者

接下来分析promise如何添加监听者。

（一）. 首先来看一下用来保存监听者对象的字段。

/**
 * One or more listeners. Can be a {@link GenericFutureListener} or a {@link DefaultFutureListeners}.
 * If {@code null}, it means either 1) no listeners were added yet or 2) all listeners were notified.
  *
  * Threading - synchronized(this). We must support adding listeners when there is no EventExecutor.
   */
    private Object listeners;

从注释可以总结出那么几个信息：

 1.这个object类型的listeners字段，可以是GenericFutureListener类型，也可以是link DefaultFutureListeners（用来保存GenericFutureListener的数组）。
 ps:这样设计的好处，多数情况下，listener只有一个，用集合或者数组会造成浪费，只有真正需要多个监听者的时候，才使用数组
 2.如果listeners为null,表示还未添加监听者或者已经触发过了（一旦触发就会将listeners清空）
 3.可以在外部添加监听者，所以使用加锁的形式（synchronized(this)）添加监听者。

（二）. 添加监听器的过程

@Override
public Promise<V> addListener(GenericFutureListener<? extends Future<? super V>> listener) {
    checkNotNull(listener, "listener");

    synchronized (this) {
        addListener0(listener);
    }

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

    return this;
}

用加锁的方式添加监听器，添加完成后，如果promise的状态为isdone,就会立即触发Listener.接下来看看addlistener0()是如何添加的。

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<? extends Future<V>>) listeners, listener);
    }
}

前面已经分析过，listeners字段只可能是GenericFutureListener类型，或者DefaultFutureListeners类型。所以如果为Null,直接保存；如果已经是DefaultFutureListeners（数组形式），就让其再添加一个listener;如果是GenericFutureListener类型，就创建一个数组。

（三）DefaultFutureListeners类分析：

首先看看它的构造方法：

DefaultFutureListeners(
        GenericFutureListener<? extends Future<?>> first, GenericFutureListener<? extends Future<?>> second) {
    listeners = new GenericFutureListener[2];
    listeners[0] = first;
    listeners[1] = second;
    size = 2;
    if (first instanceof GenericProgressiveFutureListener) {
        progressiveSize ++;
    }
    if (second instanceof GenericProgressiveFutureListener) {
        progressiveSize ++;
    }
}

可以看出，从构造之初，他就是size为2的数组。

再来看看它是如何在后续过程中添加元素的：

  public void add(GenericFutureListener<? extends Future<?>> l) {
    GenericFutureListener<? extends Future<?>>[] listeners = this.listeners;
    final int size = this.size;
    if (size == listeners.length) {
        this.listeners = listeners = Arrays.copyOf(listeners, size << 1);
    }
    listeners[size] = l;
    this.size = size + 1;

    if (l instanceof GenericProgressiveFutureListener) {
        progressiveSize ++;
    }
  }

如果数组容量未满，就继续添加元素；如果数组容量已满，就将容量翻倍，将原数组内容复制拷贝到新数组中。

（四）添加监听者总结：

1.添加完监听者，就会尝试去触发listener中的操作。
2.promise内部用来保存监听者的listeners只会是两种类型，GenericFutureListener类型和link DefaultFutureListeners。

触发监听者

在前面的setsuccess()和addlistener()等方法中都可以看到notifylisteners()方法，这就是触发监听者的起点。

private void notifyListeners() {
    EventExecutor executor = executor();
    if (executor.inEventLoop()) {
           ……
                notifyListenersNow();
           ……
    }

    safeExecute(executor, new Runnable() {
        @Override
        public void run() {
            notifyListenersNow();
        }
    });
}

private static void safeExecute(EventExecutor executor, Runnable task) {
        executor.execute(task);
    ……
}

在notifylisteners()方法中，可以看到，listener中触发的异步操作要求是在线程组中执行的，如果是在线程组外部提交的任务，会将任务封装成runnable提交到任务队列中等待执行。
接下来看看notifynow()方法中做了什么。

private void notifyListenersNow() {
    Object listeners;
    synchronized (this) {
        // Only proceed if there are listeners to notify and we are not already notifying listeners.
        if (notifyingListeners || this.listeners == null) {
            return;
        }
        notifyingListeners = true;
        listeners = this.listeners;
        this.listeners = null;
    }
    for (;;) {
        if (listeners instanceof DefaultFutureListeners) {
            notifyListeners0((DefaultFutureListeners) listeners);
        } else {
            notifyListener0(this, (GenericFutureListener<? extends Future<V>>) listeners);
        }
        synchronized (this) {
            if (this.listeners == null) {
                // Nothing can throw from within this method, so setting notifyingListeners back to false does not
                // need to be in a finally block.
                notifyingListeners = false;
                return;
            }
            listeners = this.listeners;
            this.listeners = null;
        }
    }
}

在该方法中，首先将Listeners取出来，然后将其清空（每次触发完listeners都会将原来的listeners清空），然后执行listener中具体的操作，执行完操作，会再次检查是否又有listeners添加进来，确保无误后，从方法中退出。

private static void notifyListener0(Future future, GenericFutureListener l) {
    try {
        l.operationComplete(future);
    } catch (Throwable t) {
        logger.warn("An exception was thrown by " + l.getClass().getName() + ".operationComplete()", t);
    }
}

触发监听者总结：
1.触发的listeners中具体的操作是在线程池中进行
2.触发完毕的listeners会将其清空。

同步等待

netty还提供了接口可以同步等待异步操作结果，使用到的是await()和sync()方法。

 public Promise<V> await() throws InterruptedException {
    if (isDone()) {
        return this;
    }

    if (Thread.interrupted()) {
        throw new InterruptedException(toString());
    }

    checkDeadLock();

    synchronized (this) {
        while (!isDone()) {
            incWaiters();
            try {
                wait();
            } finally {
                decWaiters();
            }
        }
    }
    return this;
 }

原理很简单，就是让线程在promise对象上等待通知。如果是isdone状态，就直接返回。
sync()方法是在await()方法的基础上添加了额外的功能，区别只是sync()调用，如果异步操作失败，则会抛出异常。

  public Promise<V> sync() throws InterruptedException {
    await();
    rethrowIfFailed();
    return this;
}

（二）defaultchannelpromise

以上分析得出一个疑惑？
从defaultpromise的分析可以得知，listener中的操作是由线程池来执行。但注意到defaultpromise的其中一个权限为protected的构造方法不需要传入eventexecutor,这可能导致出现nullpoint异常。
所以出现了另一个扩展类，defaultchannelpromise.

 public DefaultChannelPromise(Channel channel) {
    this.channel = checkNotNull(channel, "channel");
}

public DefaultChannelPromise(Channel channel, EventExecutor executor) {
    super(executor);
    this.channel = checkNotNull(channel, "channel");
}

defaultchannelpromise类有两个构造方法，一个为父类传入eventexecutor,一个调用的是上面提到的父类中protected的构造方法，那它是如何解决eventexecutor空指向的异常的？

protected EventExecutor executor() {
    EventExecutor e = super.executor();
    if (e == null) {
        return channel().eventLoop();
    } else {
        return e;
    }
}

可以看到，当eventexecutor为Null时，保存的是channel中的eventexecutor.

weixin_34007291

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫