Netty源码分析-PromiseTask

PromiseTask源码分析

 

package io.netty.util.concurrent;

import java.util.concurrent.Callable;
import java.util.concurrent.RunnableFuture;


//封装一个任务，该类的成功与失败状态只能由执行结果决定，不能通过外部设置
class PromiseTask<V> extends DefaultPromise<V> implements RunnableFuture<V> {

    //把一个Runnable对象和Result封装为一个Callable
    static <T> Callable<T> toCallable(Runnable runnable, T result) {
        return new RunnableAdapter<T>(runnable, result);
    }

    //封装Callable，Callable执行完毕后返回构造参数设置的result
    private static final class RunnableAdapter<T> implements Callable<T> {
        final Runnable task;
        final T result;

        RunnableAdapter(Runnable task, T result) {
            this.task = task;
            this.result = result;
        }
        @Override
        public T call() {
            task.run();
            return result;
        }
    }

    //待执行的任务
    protected final Callable<V> task;

    //构造参数
    PromiseTask(EventExecutor executor, Runnable runnable, V result) {
        this(executor, toCallable(runnable, result));
    }

    PromiseTask(EventExecutor executor, Callable<V> callable) {
        super(executor);
        task = callable;
    }

    @Override
    public final int hashCode() {
        return System.identityHashCode(this);
    }

    @Override
    public final boolean equals(Object obj) {
        return this == obj;
    }

    //执行任务
    @Override
    public void run() {
        try {
            //设置任务状态为不可取消,如果设置成功则开始执行任务
            if (setUncancellableInternal()) {
                //执行任务具体逻辑
                V result = task.call();
                //任务执行完成后设置result对象为结果
                setSuccessInternal(result);
            }
        } catch (Throwable e) {
            //设置异常信息
            setFailureInternal(e);
        }
    }

    //对外不可以设置异常
    @Override
    public final Promise<V> setFailure(Throwable cause) {
        throw new IllegalStateException();
    }

    //对外不可以设置异常
    protected final Promise<V> setFailureInternal(Throwable cause) {
        super.setFailure(cause);
        return this;
    }

    //对外不可以设置异常
    @Override
    public final boolean tryFailure(Throwable cause) {
        return false;
    }

    protected final boolean tryFailureInternal(Throwable cause) {
        return super.tryFailure(cause);
    }

    //对外不可以设置成功
    @Override
    public final Promise<V> setSuccess(V result) {
        throw new IllegalStateException();
    }

    protected final Promise<V> setSuccessInternal(V result) {
        super.setSuccess(result);
        return this;
    }

    //对外不可以设置成功
    @Override
    public final boolean trySuccess(V result) {
        return false;
    }

    protected final boolean trySuccessInternal(V result) {
        return super.trySuccess(result);
    }

    //对外不可以设置不可取消状态
    @Override
    public final boolean setUncancellable() {
        throw new IllegalStateException();
    }

    protected final boolean setUncancellableInternal() {
        return super.setUncancellable();
    }

    @Override
    protected StringBuilder toStringBuilder() {
        StringBuilder buf = super.toStringBuilder();
        buf.setCharAt(buf.length() - 1, ',');

        return buf.append(" task: ")
                  .append(task)
                  .append(')');
    }
}