@Override
    public V get() throws InterruptedException, ExecutionException {
        //调用await()方法进行无限期阻塞，当I/O操作完成后会被notify()。
        await();
        Throwable cause = cause();
        //程序继续向下执行，检查I/O操作是否发生了异常
        if (cause == null) {
            //如果没有异常，则通过getNow()方法获取结果并返回。
            return getNow();
        }
        //否则，将异常堆栈进行包装，抛出ExecutionException。
        throw new ExecutionException(cause);
    }

    @Override
    public V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
        //调用await(long timeout, TimeUnit unit)方法即可
        if (await(timeout, unit)) {
            Throwable cause = cause();
            //如果没有超时，则依次判断是否发生了I/O异常等情况
            if (cause == null) {
                //操作与无参数的get方法相同。
                return getNow();
            }
            throw new ExecutionException(cause);
        }
        //如果超时，则抛出TimeoutException。
        throw new TimeoutException();
    }

    @Override
    public ChannelFuture write(Object msg) {
        return write(msg, newPromise());
    }
    @Override
    public ChannelFuture write(Object msg, ChannelPromise promise) {
        DefaultChannelHandlerContext next = findContextOutbound(MASK_WRITE);
        next.invoker.invokeWrite(next, msg, promise);
        return promise;
    }
    @Override
    public ChannelPromise newPromise() {
        return new DefaultChannelPromise(channel(), executor());
    }

    @Override
    public Promise<V> setSuccess(V result) {
        //调用setSuccess0方法并对其操作结果进行判断，如果操作成功，则调用notifyListeners方法通知listener。
        if (setSuccess0(result)) {
            notifyListeners();
            return this;
        }
        throw new IllegalStateException("complete already: " + this);
    }
    private boolean setSuccess0(V result) {
        //首先判断当前Promise的操作结果是否已经被设置，如果已经被设置，则不允许重复设置，返回设置失败。
        if (isDone()) {
            return false;
        }
        //由于可能存在I/O线程和用户线程同时操作Promise，所以设置操作结果的时候需要加锁保护，防止并发操作。
        synchronized (this) {
            //对操作结果是否被设置进行二次判断（为了提升并发性能的二次判断），如果已经被设置，则返回操作失败。
            if (isDone()) {
                return false;
            }
            //对操作结果result进行判断，如果为空，说明仅仅需要notify在等待的业务线程，不包含具体的业务逻辑对象。
            //因此，将result设置为系统默认的SUCCESS。
            if (result == null) {
                this.result = SUCCESS;
            } else {
                //如果操作结果非空，将结果设置为result。
                this.result = result;
            }
            //如果有正在等待异步I/O操作完成的用户线程或者其他系统线程
            if (hasWaiters()) {
                //调用notifyAll方法唤醒所有正在等待的线程。注意，notifyAll和wait方法都必须在同步块内使用。
                notifyAll();
            }
        }
        return true;
    }

    @Override
    public Promise<V> await() throws InterruptedException {
        //如果当前的Promise已经被设置，则直接返回。
        if (isDone()) {
            return this;
        }
        //如果线程已经被中断，则抛出中断异常。
        if (Thread.interrupted()) {
            throw new InterruptedException(toString());
        }
        //通过同步关键字锁定当前Promise对象
        synchronized (this) {
            //使用循环判断对isDone结果进行判断，进行循环判断的原因是防止线程被意外唤醒导致的功能异常。
            while (!isDone()) {
                checkDeadLock();
                incWaiters();
                try {
                    wait();
                } finally {
                    decWaiters();
                }
            }
        }
        return this;
    }