Netty源码分析（一）

Future

一个future是需要返回一个结果的。两个状态管理：是否取消，是否完成

    // 如果当前任务正在执行中，ing，是否要强行停止（中断）
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() 

Executor

Executor将任务的提交和执行分离，解耦。任务结果的返回用future表示。一个任务便可分解为生产者（提交执行）和消费者（结果获取）模型。

public interface Executor {
    // 形参是runnable，所以接口的实现需要有一个Adapter适配器
    // 满足有返回值，无返回值两种条件
    void execute(Runnable command);
}

ExecutorService

执行管理者，便有提交和停止两个接口。这个管理接口便考虑到形参来源的多样性。

public interface ExecutorService extends Executor {
   void shutdown();
   <T> Future<T> submit(Callable<T> task);
   <T> Future<T> submit(Runnable task, T result);
   Future<?> submit(Runnable task);

AbstractExecutorService

这里的抽象实现，有一个可以子类继承复写的方法，newTaskFor，将不同来源的形参封装Adapter。

返回一个future，这里的future是一个可实例化的FutureTask（可运行，可获值）是一个RunnableFuture

public abstract class AbstractExecutorService implements ExecutorService {
    protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
        return new FutureTask<T>(runnable, value);
    }

    public <T> Future<T> submit(Runnable task, T result) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task, result);
        execute(ftask);
        return ftask;
    }

public interface RunnableFuture<V> extends Runnable, Future<V> {
public interface ScheduledFuture<V> extends Delayed, Future<V> {

ScheduledExecutorService

scheduled接口对ExecutorService接口增强，添加schedule调度可延时任务的能力

public interface ScheduledExecutorService extends ExecutorService {
    public <V> ScheduledFuture<V> schedule(Callable<V> callable,
                                           long delay, TimeUnit unit);

应用可基于上述基础接口实现和定制自己的任务调度器

Netty中的future增加其细粒度和能力:

done可区分原因是成功或失败

添加listener，可让结果异步执行（CallBack），可不阻塞尝试获取结果，亦可一直阻塞等任务执行完成

public interface Future<V> extends java.util.concurrent.Future<V> {
    boolean isSuccess();
    Throwable cause();
    
Future<V> addListener(GenericFutureListener<? extends Future<? super V>> listener);
Future<V> sync()  // Future<V> await()
V getNow();

GenericFutureListener当任务执行完成时，返回结果，回调

public interface GenericFutureListener<F extends Future<?>> extends EventListener {
    void operationComplete(F future) throws Exception;
}

AbstractFuture

提供一个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);
    }

Promise

future值获取（仅读）可以在future接口基础上再增强其能力，使其值表达（可写），成功，失败。

从实现来看，可反复读，仅写一次。添加listener,便有两种处理：1）添加时，值还未写，这时在写值时通知。2）添加时，值已写，立刻通知

set和try的语义不同:

set成功，返回promise自身，如果失败（已赋值，或已失败），则抛出异常

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);
    

EventExecutorGroup

EventExecutorGroup可管理多个EventExecutor。next返回一个EventExecutor，可返回自己亦可返回列表中的一个

public interface EventExecutorGroup extends ScheduledExecutorService, Iterable<EventExecutor> {
    EventExecutor next();

    @Override
    Iterator<EventExecutor> iterator();

    boolean isShuttingDown();
    Future<?> shutdownGracefully();

EventExecutor

one thread one loop，loop是线程变量，next返回this

public interface EventExecutor extends EventExecutorGroup {
    /**
     * Returns a reference to itself.
     */
    @Override
    EventExecutor next();
    
    EventExecutorGroup parent();

    boolean inEventLoop();

    boolean inEventLoop(Thread thread);
    <V> Promise<V> newPromise();
    <V> ProgressivePromise<V> newProgressivePromise();
    <V> Future<V> newSucceededFuture(V result);
    <V> Future<V> newFailedFuture(Throwable cause);

AbstractEventExecutor

inEventLoop 这里loop的实现要绑定线程，这个抽象类并没有容器，且禁用了scheduled接口

newTaskFor 默认实现是FutureTask，这里override，提供的实现是PromiseTask

public abstract class AbstractEventExecutor extends AbstractExecutorService implements EventExecutor {
        private final EventExecutorGroup parent;
    @Override
    public EventExecutor next() {
        return this;
    }

    @Override
    public boolean inEventLoop() {
        return inEventLoop(Thread.currentThread());
    }

    @Override
    public <V> Promise<V> newPromise() {
        return new DefaultPromise<V>(this);
    }
    
    @Override
    protected final <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
        return new PromiseTask<T>(this, runnable, value);
    }

AbstractScheduledEventExecutor

提供了任务容器scheduledTaskQueue

pollScheduledTask取出队列中的一个定时任务

public abstract class AbstractScheduledEventExecutor extends AbstractEventExecutor {
    PriorityQueue<ScheduledFutureTask<?>> scheduledTaskQueue;
    
    protected final Runnable pollScheduledTask(long nanoTime) {
        assert inEventLoop();

        ScheduledFutureTask<?> scheduledTask = peekScheduledTask();
        if (scheduledTask == null || scheduledTask.deadlineNanos() - nanoTime > 0) {
            return null;
        }
        scheduledTaskQueue.remove();
        scheduledTask.setConsumed();
        return scheduledTask;
    }

ScheduledFutureTask

final class ScheduledFutureTask<V> extends PromiseTask<V> implements ScheduledFuture<V>, PriorityQueueNode {

schedule如果当前是在loopThread，可直接添加。若不在，则添加到子类任务队列中

这里可看出一点。父类的scheduledTaskQueue容器，从其他线程无法往里面添加任务，而是被添加到子类任务队列中（不区分线程，但线程安全，这里的队列是并发安全的）所以其他线程添加（生产），loopThread取出（消费），没有问题

子类会将scheduledTaskQueue任务添加到taskQueue，再从taskQueue取出

private <V> ScheduledFuture<V> schedule(final ScheduledFutureTask<V> task) {
    if (inEventLoop()) {
        // scheduledTaskQueue().add(task.setId(++nextTaskId));
        scheduleFromEventLoop(task);
    } else {
        final long deadlineNanos = task.deadlineNanos();
        // task will add itself to scheduled task queue when run if not expired
        if (beforeScheduledTaskSubmitted(deadlineNanos)) {
            execute(task);
        } else {
            lazyExecute(task);
            // Second hook after scheduling to facilitate race-avoidance
            if (afterScheduledTaskSubmitted(deadlineNanos)) {
                execute(WAKEUP_TASK);
            }
        }
    }

    return task;
}

SingleThreadEventExecutor

是AbstractScheduledEventExecutor的子类

这里提供了一个普通任务队列LinkedBlockingQueue，这里便出现了Thread对象

pollTaskFrom在任务队列仅有wakeUp时，会轮转。poll是阻塞接口

当调用execute执行任务时（这里是添加任务）若没有在LoopThread，会startThread

public abstract class SingleThreadEventExecutor extends AbstractScheduledEventExecutor implements OrderedEventExecutor {
    private final Queue<Runnable> taskQueue;
    protected Queue<Runnable> newTaskQueue(int maxPendingTasks) {
        return new LinkedBlockingQueue<Runnable>(maxPendingTasks);
    }
    
private volatile Thread thread;
private final Executor executor;
private volatile ThreadProperties threadProperties;
   

startThread使用compareAndSet原语来启动loop，executor有一个线程，loop启动后赋值thread，run可启动for (;;)取任务执行

   private void startThread() {
        if (state == ST_NOT_STARTED) {
            if (STATE_UPDATER.compareAndSet(this, ST_NOT_STARTED, ST_STARTED)) {
                boolean success = false;
                try {
                    doStartThread();
                    success = true;


private void doStartThread() {
    assert thread == null;
    executor.execute(new Runnable() {
        @Override
        public void run() {
            thread = Thread.currentThread();
            boolean success = false;
            try {
                SingleThreadEventExecutor.this.run();
                success = true;
                
        for (;;) {
            Runnable task = takeTask();
            if (task != null) {
                task.run();
                updateLastExecutionTime();
            }

DefaultPromise

public class DefaultPromise<V> extends AbstractFuture<V> implements Promise<V> {
    private volatile Object result;
    private final EventExecutor executor;
    private Object listeners;

setSuccess和trySuccess是有不同的，具体的业务处理是由setSuccess0实现

addListener的通知的两个时间点

这里采取的同步原语是synchronized (this)，锁自己这个对象，保证线程安全

notifyListeners若在looperThread，直接执行，若不在，向looperThread所在的executor提交一个任务，保证线程安全

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;
}

private synchronized boolean checkNotifyWaiters() {
    if (waiters > 0) {
        notifyAll();
    }
    return listeners != null;
}

public Promise<V> setSuccess(V result) {
    if (setSuccess0(result)) {
        return this;
    }
    throw new IllegalStateException("complete already: " + this);
}

@Override
public boolean trySuccess(V result) {
    return setSuccess0(result);
}

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

        synchronized (this) {
            addListener0(listener);
        }

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

        return this;
    }


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

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

PromiseTask

前面的DefaultPromise是一个可写的future，但值是一个任务运行的结果，写事件是由任务触发的

class PromiseTask<V> extends DefaultPromise<V> implements RunnableFuture<V> {
public class FutureTask<V> implements RunnableFuture<V> {
    
    V runTask() throws Throwable {
        final Object task = this.task;
        if (task instanceof Callable) {
            return ((Callable<V>) task).call();
        }
        ((Runnable) task).run();
        return null;
    }
    
    @Override
    public void run() {
        try {
            if (setUncancellableInternal()) {
                V result = runTask();
                setSuccessInternal(result);
            }
        } catch (Throwable e) {
            setFailureInternal(e);
        }
    }
    
    protected final Promise<V> setSuccessInternal(V result) {
        super.setSuccess(result);
        clearTaskAfterCompletion(true, COMPLETED);
        return this;
    }

上述实现异步事件框架并发基础组件：

future,promise,listener,singleThreadEventExecutor(eventExecutor),promiseTask

java提供的nio

selectableChannel（支持select,poll,epoll）

SelectorProvider对nio（select,poll,epoll）进行封装

selectableChannel感兴趣的事件ops要注册到Selector，返回一个SelectionKey对象

    public abstract SelectionKey register(Selector sel, int ops, Object att)
    public abstract SelectorProvider provider();
    public abstract Set<SelectionKey> keys();
    public abstract Set<SelectionKey> selectedKeys();
    public abstract Selector wakeup();
SelectorProvider.provider().openServerSocketChannel();
SelectorProvider.provider().openSocketChannel();
SelectorProvider.provider().openSelector();

Channel

Channel接口是由内部类Unsafe实现

public interface Channel extends AttributeMap, ChannelOutboundInvoker, Comparable<Channel> {
    EventLoop eventLoop();
    Channel parent();
    ChannelPipeline pipeline();
    Unsafe unsafe();

AbstractChannel

unsafe pipeline parent在初始化时赋值，eventLoop是在注册时赋值，因为channel是注册到eventLoop中

事件发生在unsafe，通过pipeline 传播

public abstract class AbstractChannel extends DefaultAttributeMap implements Channel {
    protected AbstractChannel(Channel parent) {
        this.parent = parent;
        id = newId();
        unsafe = newUnsafe();
        pipeline = newChannelPipeline();
    }
    private volatile EventLoop eventLoop;
    private volatile boolean registered;
    
public final void register(EventLoop eventLoop, final ChannelPromise promise) {
            AbstractChannel.this.eventLoop = eventLoop;

            if (eventLoop.inEventLoop()) {
                register0(promise);
            } else {
                try {
                    eventLoop.execute(new Runnable() {
                        @Override
                        public void run() {
                            register0(promise);
                        }
                    });

EventLoopGroup

public interface EventLoopGroup extends EventExecutorGroup {
    EventLoop next();
    ChannelFuture register(Channel channel);

EventLoop

public interface EventLoop extends OrderedEventExecutor, EventLoopGroup {
    @Override
    EventLoopGroup parent();
}

ChannelHandlerContext

ChannelInboundInvoker 方法带有fire前缀，且返回对象是自己ChannelInboundInvoker
    ChannelRegistered ChannelUnregistered
    ChannelActive ChannelInactive
    ExceptionCaught
    ChannelRead ChannelReadComplete

public interface ChannelHandlerContext extends AttributeMap, ChannelInboundInvoker, ChannelOutboundInvoker {
        Channel channel();
    EventExecutor executor();
    ChannelHandler handler();
    ChannelPipeline pipeline();

public interface ChannelOutboundHandler extends ChannelHandler {
public interface ChannelInboundHandler extends ChannelHandler {

ChannelPipeline

事件通过Pipeline传播，可进行拦截和处理

firstContext first = head.next

public interface ChannelPipeline
        extends ChannelInboundInvoker, ChannelOutboundInvoker, Iterable<Entry<String, ChannelHandler>> {

    @Override
    public final ChannelHandlerContext firstContext() {
        AbstractChannelHandlerContext first = head.next;
        if (first == tail) {
            return null;
        }
        return head.next;
    }

AbstractChannelHandlerContext

findContextInbound next

findContextOutbound prev

abstract class AbstractChannelHandlerContext implements ChannelHandlerContext, ResourceLeakHint {
    volatile AbstractChannelHandlerContext next;
    volatile AbstractChannelHandlerContext prev;
    private final DefaultChannelPipeline pipeline;
    final EventExecutor executor;
    
    private AbstractChannelHandlerContext findContextInbound(int mask) {
        AbstractChannelHandlerContext ctx = this;
        EventExecutor currentExecutor = executor();
        do {
            ctx = ctx.next;
        } while (skipContext(ctx, currentExecutor, mask, MASK_ONLY_INBOUND));
        return ctx;
    }

    private AbstractChannelHandlerContext findContextOutbound(int mask) {
        AbstractChannelHandlerContext ctx = this;
        EventExecutor currentExecutor = executor();
        do {
            ctx = ctx.prev;
        } while (skipContext(ctx, currentExecutor, mask, MASK_ONLY_OUTBOUND));
        return ctx;
    }

AbstractNioChannel

有SelectableChannel NioEventLoop 成员

java nio SelectableChannel和Netty的channel接口实现

doRegister的实现SelectableChannel.register

public abstract class AbstractNioChannel extends AbstractChannel {
    private final SelectableChannel ch;
    protected final int readInterestOp;
    volatile SelectionKey selectionKey;

    protected SelectableChannel javaChannel() {
        return ch;
    }
    
    @Override
    public NioEventLoop eventLoop() {
        return (NioEventLoop) super.eventLoop();
    }
    
    protected void doRegister() throws Exception {
        boolean selected = false;
        for (;;) {
            try {
                selectionKey = javaChannel().register(eventLoop().unwrappedSelector(), 0, this);

doBeginRead注册read事件

@Override
protected void doBeginRead() throws Exception {
    // Channel.read() or ChannelHandlerContext.read() was called
    final SelectionKey selectionKey = this.selectionKey;
    if (!selectionKey.isValid()) {
        return;
    }

    readPending = true;

    final int interestOps = selectionKey.interestOps();
    if ((interestOps & readInterestOp) == 0) {
        selectionKey.interestOps(interestOps | readInterestOp);
    }
}

public abstract class AbstractNioByteChannel extends AbstractNioChannel {
public abstract class AbstractNioMessageChannel extends AbstractNioChannel {
    private final class NioMessageUnsafe extends AbstractNioUnsafe {
// socket原始数据加工
read doWrite

NioServerSocketChannel

openServerSocketChannel

SelectionKey.OP_ACCEPT 感兴趣的事件

public class NioServerSocketChannel extends AbstractNioMessageChannel
                             implements io.netty.channel.socket.ServerSocketChannel {
    private static final SelectorProvider DEFAULT_SELECTOR_PROVIDER = SelectorProvider.provider();

        super(null, channel, SelectionKey.OP_ACCEPT);
        config = new NioServerSocketChannelConfig(this, javaChannel().socket());

OP_ACCEPT 事件发生，调用accept，返回一个SocketChannel

server有一个新的连接

@Override
protected int doReadMessages(List<Object> buf) throws Exception {
    SocketChannel ch = SocketUtils.accept(javaChannel());

    try {
        if (ch != null) {
            buf.add(new NioSocketChannel(this, ch));
            return 1;
        }

NioEventLoop

public final class NioEventLoop extends SingleThreadEventLoop {