天瑕
天瑕

较真儿学源码系列-Netty核心流程源码分析

目录

1 简介

1.1 线程模型

1.2 ChannelHandler & ChannelPipeline

1.3 直接内存

2 NioEventLoopGroup

3 ServerBootstrap & Bootstrap

3.1 构造器

3.2 group方法

3.3 channel方法

3.4 option方法

3.5 childHandler & handler方法

3.6 bind & connect方法

4 sync方法

5 writeAndFlush方法

6 心跳检测机制

6.1 构造器

6.2 channelActive方法

6.3 channelRead方法

Netty版本：4.1.51.Final。

1 简介

因为NIO的类库和API比较繁琐，使用起来比较麻烦，开发的工作量和难度都非常大，例如客户端面临断连重连、网络闪断、心跳处理、半包读写、网络拥塞和异常流的处理等等。所以Netty对Java自带的NIO API进行了良好的封装，解决了上述问题。且Netty拥有高性能、吞吐量更高、延迟更低、减少资源消耗，零拷贝直接内存等优点。所以Netty可以很方便地实现出一个网络通信系统，比如聊天服务器或弹幕系统（我曾经使用Netty实现过一个简易聊天室的demo，感兴趣的可以查看《Netty实现简易聊天室的功能》），同时在分布式框架中，像阿里的Dubbo和RocketMQ，底层使用的就是Netty来作为基础通信组件。

需要注意的是：Netty曾经有Netty 5这个版本，但是后来被废弃掉了，现在使用的都是Netty 4的版本。之所以被废弃，最主要的原因是Netty 5中使用了ForkJoinPool，增加了代码的复杂性却没有很明显的性能提升，同时增加了没有必要的多版本分支的维护工作（Norman Maurer（《Netty IN ACTION》作者，同时他现在也在领导着Netty项目）的原话在此https://github.com/netty/netty/issues/4466）。

值得一提的是：在2016年Norman Maurer曾经对Netty做过一次演讲，详细介绍了4.x版本相对于3.x版本所做的改进之处。讲解的非常好，感兴趣的可以查看《Netty - One Framework to rule them all....》（中文字幕版）。

1.1 线程模型

Netty使用的是NIO的模型（我之前写过一篇讲解BIO、NIO和AIO的文章，感兴趣的可以查看《BIO & NIO & AIO》），但是对于NIO模型来说，我当时示例代码的服务端是只用了一个线程来处理。那么假如此时有十万多个客户端需要和服务端IO交互，而其中某一个客户端和服务端的IO交互花费时间很长，剩下的十万个IO请求就都会被阻塞住。即使服务端使用的是线程池，服务端也不可能开十万个线程，多余的线程也会被放在阻塞队列中进行阻塞。所以在Netty中又进一步优化了原有NIO的模型：

较真儿学源码系列-Netty核心流程源码分析_第1张图片

上面就是Netty的线程模型图，其中客户端我没有细画是因为其执行逻辑和服务端大致都是类似的，只不过客户端只有一组线程组（WorkerGroup），而不是服务端的两组（BossGroup和WorkerGroup）。

在服务端中BossGroup只负责接收客户端的连接（一般只需要一个线程就可以了，如果需要监听多个端口才需要开多个NioEventLoop）；而WorkerGroup专门负责网络的读写，是真正干活的线程，WorkerGroup做成多个NioEventLoop的话就会有多个selector来处理客户端的IO请求。Netty通过这种方式来实现对连接IO操作和读写IO操作的分离，让两者之间不会受干扰，不会出现一个读写IO非常慢从而导致后面的连接IO被阻塞的情况。同时如果连接IO出现问题的话，往往是网络出现异常；而读写IO出现问题可能是业务代码逻辑上有问题。这样就可以通过职责分离，快速定位出问题所在（分治的思想通常是实现任何可扩展性目标的最佳方法）。

每个NioEventLoop（可以把NioEventLoop理解为一个线程，而NioEventLoopGroup就相当于线程池）都会循环做三件事：

  1. select：BossGroup中的select方法是用来处理accept事件，WorkerGroup中的select方法是用来处理read或write事件，而客户端的select方法是用来处理connect、read或write事件；
  2. processSelectedKeys：BossGroup中的processSelectedKeys方法是用来注册客户端的NioSocketChannel到workerGroup的一个selector上，WorkerGroup中的processSelectedKeys方法是用来处理客户端的I/O事件（在pipeline上遍历处理），而客户端的processSelectedKeys方法是用来处理服务端的I/O事件；
  3. runAllTasks：用来处理任务队列taskQueue和定时任务队列scheduledTaskQueue中的任务。

其实这里Netty的线程模型源自于Doug Lea大神写过的一篇文章《Scalable IO in Java》中的Multiple Reactors模型：

较真儿学源码系列-Netty核心流程源码分析_第2张图片

1.2 ChannelHandler & ChannelPipeline

ChannelHandler是处理服务端和客户端入站（站在客户端的角度来说，服务端往客户端发送数据；或者站在服务端的角度来说，客户端往服务端发送数据叫做入站）和出站（站在客户端的角度来说，客户端往服务端发送数据；或者站在服务端的角度来说，服务端往客户端发送数据叫做出站）的逻辑容器，具体可分为ChannelInboundHandler和ChannelOutboundHandler。ChannelInboundHandler是用来处理入站逻辑的，而ChannelOutboundHandler是用来处理出站逻辑的。比方说我现在写了一个自定义编解码的逻辑，那么ChannelInboundHandler就是写解码逻辑的，而ChannelOutboundHandler是写编码逻辑的。当然Netty中也内置了一些ChannelHandler，比如说对String的编解码逻辑StringEncoder和StringDecoder，对象的编解码逻辑ObjectEncoder和ObjectDecoder等。

如上面的Netty线程模型图所示，在处理实际业务时用到的就是ChannelHandler。但是上面的图画的只是一个大概，完整的服务端和客户端ChannelHandler的交互示意图如下所示：

较真儿学源码系列-Netty核心流程源码分析_第3张图片

如果有多个ChannelHandler，那么它们之间是通过ChannelPipeline的方式来组合使用的，也就是说通过pipeline可以将所有的ChannelInboundHandler和ChannelOutboundHandler组合成一个处理链，但是并不是一次会把所有的ChannelHandler都执行。如上图所示：在入站的时候，只会从pipeline的head向tail方向执行处理链上所有的ChannelInboundHandler，遇到ChannelOutboundHandler的时候会跳过；而在出站的时候，只会从pipeline的tail向head方向执行处理链上所有的ChannelOutboundHandler，遇到ChannelInboundHandler的时候会跳过。

有一点需要注意的是：在一条处理链中所有出站的handler，它们之间的顺序不是随便写的。比如说我现在有一个发送数据的handler和一个编码的handler。因为出站的顺序是从pipeline的tail到head，所以发送数据的handler一定要放在编码handler的后面，也就是必须要先发送数据再编码。如果这个顺序反了，就变成了先编码再发送数据，那么就不会发送成功数据，逻辑就有问题了。同时对于所有入站的handler也是一样的道理。因为入站的顺序是从pipeline的head到tail，所以接收数据的handler也是一定要放在解码handler的后面，也就是必须要先解码再接收数据。

1.3 直接内存

直接内存是相对于堆内存来说的，它并不是JVM运行时数据区的一部分，也不是Java虚拟机规范中定义的内存区域。某些情况下直接内存也会被频繁地使用，而且也有可能会导致OOM的出现。元空间对应的内存可以叫作直接内存，同时在NIO编程中用DirectByteBuffer也可以分配一块直接内存，它们对应的都是机器的物理内存。

但是在NIO编程中直接内存的API非常难用，稍不留意就会写出bug。所以在Netty中已经帮我们封装为了ByteBuf类，使用起来更加方便。ByteBuf的大致数据结构如下：

较真儿学源码系列-Netty核心流程源码分析_第4张图片

每调用一次writeByte方法，writerIndex指针就+1；每调用一次readByte方法，readerIndex指针就+1；而getByte方法是不会造成指针移动的。所以就可以依据这两个指针划分为三个区间：

  • [0, readerIndex)：代表已经读取过的区域；
  • [readerIndex, writerIndex)：代表可以读取但还没读取的区域；
  • [writerIndex, capacity)：代表可以写的区域。

值得一提的是：直接内存虽然执行速度更快，但是其创建和销毁是很耗时间的（起码比堆内存慢）。所以在Netty中，对ByteBuf使用了内存池的缓冲区重用机制，提前放进去了一些ByteBuf。

2 NioEventLoopGroup

在上面的Netty线程模型图中，bossGroup和workerGroup就是NioEventLoopGroup，也就是Netty自己封装的线程池。

/**
 * NioEventLoopGroup:
 * 无参构造器
 */
public NioEventLoopGroup() {
    //这里nThreads会赋值为0
    this(0);
}

/**
 * 有参构造器
 */
public NioEventLoopGroup(int nThreads) {
    this(nThreads, (Executor) null);
}

public NioEventLoopGroup(int nThreads, Executor executor) {
    this(nThreads, executor, SelectorProvider.provider());
}

public NioEventLoopGroup(
        int nThreads, Executor executor, final SelectorProvider selectorProvider) {
    this(nThreads, executor, selectorProvider, DefaultSelectStrategyFactory.INSTANCE);
}

public NioEventLoopGroup(int nThreads, Executor executor, final SelectorProvider selectorProvider,
                         final SelectStrategyFactory selectStrategyFactory) {
    super(nThreads, executor, selectorProvider, selectStrategyFactory, RejectedExecutionHandlers.reject());
}

/**
 * MultithreadEventLoopGroup:
 */
protected MultithreadEventLoopGroup(int nThreads, Executor executor, Object... args) {
    /*
    从这里可以看到，如果是无参构造器，传进来的nThreads就是0，那么就会为DEFAULT_EVENT_LOOP_THREADS
    而DEFAULT_EVENT_LOOP_THREADS值的初始化过程在下面，默认为当前JVM最大可用线程数*2
     */
    super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, args);
}

public abstract class MultithreadEventLoopGroup extends MultithreadEventExecutorGroup implements EventLoopGroup {
    //...

    private static final int DEFAULT_EVENT_LOOP_THREADS;

    static {
        /*
        如果用户没有设置“io.netty.eventLoopThreads”和“io.netty.availableProcessors”这两个参数，
        DEFAULT_EVENT_LOOP_THREADS的值就默认为当前JVM最大可用线程数*2（至少要为1）
         */
        DEFAULT_EVENT_LOOP_THREADS = Math.max(1, SystemPropertyUtil.getInt(
                "io.netty.eventLoopThreads", NettyRuntime.availableProcessors() * 2));

        if (logger.isDebugEnabled()) {
            logger.debug("-Dio.netty.eventLoopThreads: {}", DEFAULT_EVENT_LOOP_THREADS);
        }
    }

    //...
}

/**
 * MultithreadEventExecutorGroup:
 * 第39行代码处：
 */
protected MultithreadEventExecutorGroup(int nThreads, Executor executor, Object... args) {
    this(nThreads, executor, DefaultEventExecutorChooserFactory.INSTANCE, args);
}

protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
                                        EventExecutorChooserFactory chooserFactory, Object... args) {
    if (nThreads <= 0) {
        throw new IllegalArgumentException(String.format("nThreads: %d (expected: > 0)", nThreads));
    }

    /*
    不管是有参构造器还是无参构造器，传进来的executor都是null，所以在此进行初始化的工作，
    赋值为一个Netty封装过的executor
     */
    if (executor == null) {
        executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());
    }

    //EventExecutor也是Netty封装过的线程池接口，这里的children就相当于一个线程池
    children = new EventExecutor[nThreads];

    for (int i = 0; i < nThreads; i++) {
        boolean success = false;
        try {
            /*
            这里默认会调用NioEventLoopGroup的newChild方法从而new出一个NioEventLoop，相当于一个Netty封装过的线程
            （实际上是相当于线程池，只不过这个线程池里只会有一个线程）。现在再来看一下之前的Netty线程模型图：children就
            相当于bossGroup或workerGroup，而其中的每一个元素就是NioEventLoop
             */
            children[i] = newChild(executor, args);
            success = true;
        } catch (Exception e) {
            throw new IllegalStateException("failed to create a child event loop", e);
        } finally {
            if (!success) {
                for (int j = 0; j < i; j++) {
                    children[j].shutdownGracefully();
                }

                for (int j = 0; j < i; j++) {
                    EventExecutor e = children[j];
                    try {
                        while (!e.isTerminated()) {
                            e.awaitTermination(Integer.MAX_VALUE, TimeUnit.SECONDS);
                        }
                    } catch (InterruptedException interrupted) {
                        Thread.currentThread().interrupt();
                        break;
                    }
                }
            }
        }
    }

    //这里会调用DefaultEventExecutorChooserFactory的newChooser方法
    chooser = chooserFactory.newChooser(children);

    final FutureListener terminationListener = new FutureListener() {
        @Override
        public void operationComplete(Future future) throws Exception {
            if (terminatedChildren.incrementAndGet() == children.length) {
                terminationFuture.setSuccess(null);
            }
        }
    };

    for (EventExecutor e : children) {
        e.terminationFuture().addListener(terminationListener);
    }

    //根据children构建不可修改readonlyChildren
    Set childrenSet = new LinkedHashSet(children.length);
    Collections.addAll(childrenSet, children);
    readonlyChildren = Collections.unmodifiableSet(childrenSet);
}

/**
 * NioEventLoopGroup:
 * 第96行代码处：
 */
@Override
protected EventLoop newChild(Executor executor, Object... args) throws Exception {
    EventLoopTaskQueueFactory queueFactory = args.length == 4 ? (EventLoopTaskQueueFactory) args[3] : null;
    return new NioEventLoop(this, executor, (SelectorProvider) args[0],
            ((SelectStrategyFactory) args[1]).newSelectStrategy(), (RejectedExecutionHandler) args[2], queueFactory);
}

/**
 * NioEventLoop:
 */
NioEventLoop(NioEventLoopGroup parent, Executor executor, SelectorProvider selectorProvider,
             SelectStrategy strategy, RejectedExecutionHandler rejectedExecutionHandler,
             EventLoopTaskQueueFactory queueFactory) {
    super(parent, executor, false, newTaskQueue(queueFactory), newTaskQueue(queueFactory),
            rejectedExecutionHandler);
    this.provider = ObjectUtil.checkNotNull(selectorProvider, "selectorProvider");
    this.selectStrategy = ObjectUtil.checkNotNull(strategy, "selectStrategy");
    //该方法里面会完成NIO的selectedKeys的初始化
    final NioEventLoop.SelectorTuple selectorTuple = openSelector();
    //这里进行对NIO的selector的初始化，也就是在上面Netty线程模型图中，每一个NioEventLoop都有一个selector的体现
    this.selector = selectorTuple.selector;
    this.unwrappedSelector = selectorTuple.unwrappedSelector;
}

/**
 * SingleThreadEventLoop:
 * 第160行代码处：
 */
protected SingleThreadEventLoop(EventLoopGroup parent, Executor executor,
                                boolean addTaskWakesUp, Queue taskQueue, Queue tailTaskQueue,
                                RejectedExecutionHandler rejectedExecutionHandler) {
    super(parent, executor, addTaskWakesUp, taskQueue, rejectedExecutionHandler);
    tailTasks = ObjectUtil.checkNotNull(tailTaskQueue, "tailTaskQueue");
}

/**
 * SingleThreadEventExecutor:
 * 第178行代码处：
 */
protected SingleThreadEventExecutor(EventExecutorGroup parent, Executor executor,
                                    boolean addTaskWakesUp, Queue taskQueue,
                                    RejectedExecutionHandler rejectedHandler) {
    super(parent);
    this.addTaskWakesUp = addTaskWakesUp;
    this.maxPendingTasks = DEFAULT_MAX_PENDING_EXECUTOR_TASKS;
    //这里进行对executor的初始化
    this.executor = ThreadExecutorMap.apply(executor, this);
    //这里进行对taskQueue的初始化
    this.taskQueue = ObjectUtil.checkNotNull(taskQueue, "taskQueue");
    this.rejectedExecutionHandler = ObjectUtil.checkNotNull(rejectedHandler, "rejectedHandler");
}

/**
 * DefaultEventExecutorChooserFactory:
 * 第122行代码处：
 */
@SuppressWarnings("unchecked")
@Override
public EventExecutorChooser newChooser(EventExecutor[] executors) {
    /*
    这里会根据executors的长度是否是2的幂来选择调用PowerOfTwoEventExecutorChooser
    或GenericEventExecutorChooser。之所以有这个区别是因为后续会调用到next方法，
    而next方法会通过取余的方式来找到下一个EventExecutor。而如果长度为2的幂的话，会有
    优化的写法而不是使用默认的“%”取余符号，后续会详细讲解
     */
    if (isPowerOfTwo(executors.length)) {
        return new PowerOfTwoEventExecutorChooser(executors);
    } else {
        return new GenericEventExecutorChooser(executors);
    }
}

/**
 * 第212行代码处：
 * 该方法是用来判断val是否是2的幂。一个数的负数和原数的二进制形式的区别是取反再+1
 * 所以只有val是2的幂的时候，这个数和它取负数的数在最后val.length个位数长度上的
 * 数是完全一样的。所以两者按位与的结果就是这个数，以此就可以判断出来是否是2的幂了
 * 举个例子：假如说val是3，二进制是11。而-3的二进制是1111 1111 1111 1111 1111 1111 1111 1101
 * 两者在最后两位分别是11和01，是不一样的，所以按位与的结果肯定不是11，也就是十进制的3；
 * 那么假如说val是4，二进制是100；而-4的二进制是1111 1111 1111 1111 1111 1111 1111 1100
 * 两者在最后三位都是100，所以按位与的结果就是100，也就是十进制的4，也就是判断是相等的
 */
private static boolean isPowerOfTwo(int val) {
    return (val & -val) == val;
}

/**
 * 第213行代码处：
 */
PowerOfTwoEventExecutorChooser(EventExecutor[] executors) {
    //这里将children赋值进PowerOfTwoEventExecutorChooser的executors
    this.executors = executors;
}

/**
 * 第215行代码处：
 */
GenericEventExecutorChooser(EventExecutor[] executors) {
    //这里将children赋值进GenericEventExecutorChooser的executors
    this.executors = executors;
} 
  
 
  
3 ServerBootstrap & Bootstrap
 
  
Bootstrap在Netty中是启动的辅助类，可以在其中加上一些配置项。具体可分为服务端的ServerBootstrap和客户端的Bootstrap。
 
  
3.1 构造器
 
  
/**
 * ServerBootstrap:
 */
public ServerBootstrap() {
    //这里虽然是空实现，但在ServerBootstrap类中会完成如下所示的初始化工作
}

public class ServerBootstrap extends AbstractBootstrap {
    //...

    private final Map, Object> childOptions = new LinkedHashMap, Object>();
    private final Map, Object> childAttrs = new ConcurrentHashMap, Object>();
    private final ServerBootstrapConfig config = new ServerBootstrapConfig(this);

    //...
}

/**
 * ServerBootstrapConfig:
 * 第13行代码处：
 */
ServerBootstrapConfig(ServerBootstrap bootstrap) {
    super(bootstrap);
}

/**
 * AbstractBootstrapConfig:
 */
protected AbstractBootstrapConfig(B bootstrap) {
    //这里会将ServerBootstrap赋值给this.bootstrap
    this.bootstrap = ObjectUtil.checkNotNull(bootstrap, "bootstrap");
}

/**
 * Bootstrap:
 */
public Bootstrap() {
    //这里虽然是空实现，但在Bootstrap类中会完成如下所示的初始化工作
}

public class Bootstrap extends AbstractBootstrap {
    //...

    private final BootstrapConfig config = new BootstrapConfig(this);

    //...
}

/**
 * BootstrapConfig:
 * 第44行代码处：
 */
BootstrapConfig(Bootstrap bootstrap) {
    //这里会一样调用AbstractBootstrapConfig的构造器，将Bootstrap赋值给AbstractBootstrapConfig.bootstrap
    super(bootstrap);
}
 
  
3.2 group方法
 
  
/**
 * ServerBootstrap:
 * ServerBootstrap中的bossGroup会赋值给AbstractBootstrap的group；
 * 而workerGroup会赋值给ServerBootstrap的childGroup
 */
public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup) {
    //会调用到AbstractBootstrap的group方法
    super.group(parentGroup);
    if (this.childGroup != null) {
        throw new IllegalStateException("childGroup set already");
    }
    this.childGroup = ObjectUtil.checkNotNull(childGroup, "childGroup");
    return this;
}

/**
 * AbstractBootstrap:
 * 第8行代码处、以及Bootstrap调用group方法处：
 * Bootstrap中的workerGroup会赋值给AbstractBootstrap的group
 */
public B group(EventLoopGroup group) {
    ObjectUtil.checkNotNull(group, "group");
    if (this.group != null) {
        throw new IllegalStateException("group set already");
    }
    this.group = group;
    return self();
}

@SuppressWarnings("unchecked")
private B self() {
    return (B) this;
}

 
  
3.3 channel方法
 
  
/**
 * AbstractBootstrap:
 */
public B channel(Class channelClass) {
    //这里传进来的是NioServerSocketChannel（服务端）或NioSocketChannel（客户端）
    return channelFactory(new ReflectiveChannelFactory(
            ObjectUtil.checkNotNull(channelClass, "channelClass")
    ));
}

/**
 * ReflectiveChannelFactory:
 */
public ReflectiveChannelFactory(Class clazz) {
    ObjectUtil.checkNotNull(clazz, "clazz");
    try {
        /*
        把NioServerSocketChannel或NioSocketChannel的空参数构造器赋值进constructor，
        后续会通过反射的方式进行调用
         */
        this.constructor = clazz.getConstructor();
    } catch (NoSuchMethodException e) {
        throw new IllegalArgumentException("Class " + StringUtil.simpleClassName(clazz) +
                " does not have a public non-arg constructor", e);
    }
}

/**
 * AbstractBootstrap:
 * 第6行代码处：
 */
public B channelFactory(io.netty.channel.ChannelFactory channelFactory) {
    return channelFactory((io.netty.bootstrap.ChannelFactory) channelFactory);
}

@Deprecated
public B channelFactory(io.netty.bootstrap.ChannelFactory channelFactory) {
    ObjectUtil.checkNotNull(channelFactory, "channelFactory");
    if (this.channelFactory != null) {
        throw new IllegalStateException("channelFactory set already");
    }

    //把ReflectiveChannelFactory赋值给channelFactory
    this.channelFactory = channelFactory;
    return self();
}
 
  
3.4 option方法
 
  
/**
 * AbstractBootstrap:
 */
public  B option(ChannelOption option, T value) {
    ObjectUtil.checkNotNull(option, "option");
    //options是一个LinkedHashMap，里面存放着存进来的TCP定制化参数
    synchronized (options) {
        if (value == null) {
            options.remove(option);
        } else {
            options.put(option, value);
        }
    }
    return self();
}
 
  
3.5 childHandler & handler方法
 
  
/**
 * ServerBootstrap:
 */
public ServerBootstrap childHandler(ChannelHandler childHandler) {
    /*
    这里就是把传进来的ChannelInitializer赋值给childHandler，而我们在其中实现的initChannel方法
    会在channel被注册时回调，ChannelInitializer实例会在initChannel方法执行完毕后被销毁
    后续会看到这一点
     */
    this.childHandler = ObjectUtil.checkNotNull(childHandler, "childHandler");
    return this;
}

/**
 * AbstractBootstrap:
 */
public B handler(ChannelHandler handler) {
    /*
    这里就是把传进来的ChannelInitializer赋值给handler，而我们在其中实现的initChannel方法
    会在channel被注册时回调，ChannelInitializer实例会在initChannel方法执行完毕后被销毁
    后续会看到这一点
     */
    this.handler = ObjectUtil.checkNotNull(handler, "handler");
    return self();
}
 
  
3.6 bind & connect方法
 
  
bind方法看起来就是一个绑定端口的方法，实则完成服务端启动的全过程，流程不仅长而且还很复杂。而前面这些方法都只是在做一些配置而已。
 
  
而connect方法是客户端连接服务端的方法，其执行过程和bind方法大致类似，所以这里只挑出实现不一样的地方来进行分析。
 
  
/**
 * AbstractBootstrap:
 * 这里是服务端的bind方法
 */
public ChannelFuture bind(int inetPort) {
    return bind(new InetSocketAddress(inetPort));
}

public ChannelFuture bind(SocketAddress localAddress) {
    validate();
    return doBind(ObjectUtil.checkNotNull(localAddress, "localAddress"));
}

private ChannelFuture doBind(final SocketAddress localAddress) {
    //完成channel的初始化和注册过程
    final ChannelFuture regFuture = initAndRegister();
    final Channel channel = regFuture.channel();
    if (regFuture.cause() != null) {
        return regFuture;
    }

    if (regFuture.isDone()) {
        ChannelPromise promise = channel.newPromise();
        doBind0(regFuture, channel, localAddress, promise);
        return promise;
    } else {
        final PendingRegistrationPromise promise = new PendingRegistrationPromise(channel);
        regFuture.addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                Throwable cause = future.cause();
                if (cause != null) {
                    promise.setFailure(cause);
                } else {
                    promise.registered();

                    doBind0(regFuture, channel, localAddress, promise);
                }
            }
        });
        return promise;
    }
}

/**
 * Bootstrap:
 * 这里是客户端的connect方法
 */
public ChannelFuture connect(String inetHost, int inetPort) {
    return connect(InetSocketAddress.createUnresolved(inetHost, inetPort));
}

public ChannelFuture connect(SocketAddress remoteAddress) {
    ObjectUtil.checkNotNull(remoteAddress, "remoteAddress");
    validate();
    return doResolveAndConnect(remoteAddress, config.localAddress());
}

private ChannelFuture doResolveAndConnect(final SocketAddress remoteAddress, final SocketAddress localAddress) {
    //完成channel的初始化和注册过程
    final ChannelFuture regFuture = initAndRegister();
    final Channel channel = regFuture.channel();

    if (regFuture.isDone()) {
        if (!regFuture.isSuccess()) {
            return regFuture;
        }
        return doResolveAndConnect0(channel, remoteAddress, localAddress, channel.newPromise());
    } else {
        final PendingRegistrationPromise promise = new PendingRegistrationPromise(channel);
        regFuture.addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                Throwable cause = future.cause();
                if (cause != null) {
                    promise.setFailure(cause);
                } else {
                    promise.registered();
                    doResolveAndConnect0(channel, remoteAddress, localAddress, promise);
                }
            }
        });
        return promise;
    }
}

/**
 * 第16行和第61行代码处：
 * 可以看到服务端和客户端都调用了initAndRegister方法，那么下面就来看一下其实现
 */
final ChannelFuture initAndRegister() {
    Channel channel = null;
    try {
        //这里会调用到我们之前在channel方法中创建的ReflectiveChannelFactory的newChannel方法
        channel = channelFactory.newChannel();
        init(channel);
    } catch (Throwable t) {
        if (channel != null) {
            channel.unsafe().closeForcibly();
            return new DefaultChannelPromise(channel, GlobalEventExecutor.INSTANCE).setFailure(t);
        }
        return new DefaultChannelPromise(new FailedChannel(), GlobalEventExecutor.INSTANCE).setFailure(t);
    }

    //这里的group方法拿到的就是bossGroup 这里也就是在对channel进行注册
    ChannelFuture regFuture = config().group().register(channel);
    if (regFuture.cause() != null) {
        if (channel.isRegistered()) {
            channel.close();
        } else {
            channel.unsafe().closeForcibly();
        }
    }

    return regFuture;
}

/**
 * ReflectiveChannelFactory:
 * 第95行代码处：
 */
@Override
public T newChannel() {
    try {
        /*
        之前constructor指向的是NioServerSocketChannel（服务端）或NioSocketChannel（客户端），
        所以在这里调用了其空参数构造器
         */
        return constructor.newInstance();
    } catch (Throwable t) {
        throw new ChannelException("Unable to create Channel from class " + constructor.getDeclaringClass(), t);
    }
}

/**
 * NioServerSocketChannel:
 * 第129行代码处：
 */
public NioServerSocketChannel() {
    this(newSocket(DEFAULT_SELECTOR_PROVIDER));
}

/**
 * 这里可以看到通过newSocket方法来生成了一个ServerSocketChannel。而本方法的返回值
 * ServerSocketChannel不就是NIO的ServerSocketChannel吗？所以这里就可以看出
 * NioServerSocketChannel就是对原生NIO的ServerSocketChannel的包装
 */
private static ServerSocketChannel newSocket(SelectorProvider provider) {
    try {
        return provider.openServerSocketChannel();
    } catch (IOException e) {
        throw new ChannelException(
                "Failed to open a server socket.", e);
    }
}

/**
 * 第140行代码处：
 */
public NioServerSocketChannel(ServerSocketChannel channel) {
    //这里的OP_ACCEPT正是在之前NIO编程中，对ServerSocketChannel注册OP_ACCEPT事件的相关代码
    super(null, channel, SelectionKey.OP_ACCEPT);
    config = new NioServerSocketChannelConfig(this, javaChannel().socket());
}

/**
 * AbstractNioMessageChannel:
 * 第162行代码处：
 */
protected AbstractNioMessageChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
    super(parent, ch, readInterestOp);
}

/**
 * NioSocketChannel:
 * 第129行代码处：
 * 这里先不去查看AbstractNioMessageChannel的super方法，先来看一下客户端的NioSocketChannel的无参构造器
 */
public NioSocketChannel() {
    this(DEFAULT_SELECTOR_PROVIDER);
}

public NioSocketChannel(SelectorProvider provider) {
    this(newSocket(provider));
}

/**
 * 这里跟NioServerSocketChannel一样，NioSocketChannel就是对原生
 * NIO的SocketChannel的包装
 */
private static SocketChannel newSocket(SelectorProvider provider) {
    try {
        return provider.openSocketChannel();
    } catch (IOException e) {
        throw new ChannelException("Failed to open a socket.", e);
    }
}

/**
 * 第184行代码处：
 */
public NioSocketChannel(SocketChannel socket) {
    this(null, socket);
}

public NioSocketChannel(Channel parent, SocketChannel socket) {
    super(parent, socket);
    config = new NioSocketChannelConfig(this, socket.socket());
}

/**
 * AbstractNioByteChannel:
 * 第207行代码处：
 */
protected AbstractNioByteChannel(Channel parent, SelectableChannel ch) {
    /*
    同服务端，这里跟NIO编程一样，对SocketChannel注册OP_READ事件，
    同时也调用了AbstractNioMessageChannel的super方法
     */
    super(parent, ch, SelectionKey.OP_READ);
}

/**
 * AbstractNioChannel:
 * 第171行和第220行代码处：
 * NioServerSocketChannel和NioSocketChannel都会调用到此处
 */
protected AbstractNioChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
    super(parent);
    this.ch = ch;
    //把注册事件赋值给readInterestOp
    this.readInterestOp = readInterestOp;
    try {
        //下面这行代码在NIO编程也是一样的，将ServerSocketChannel或SocketChannel配置为非阻塞模式
        ch.configureBlocking(false);
    } catch (IOException e) {
        try {
            ch.close();
        } catch (IOException e2) {
            logger.warn(
                    "Failed to close a partially initialized socket.", e2);
        }

        throw new ChannelException("Failed to enter non-blocking mode.", e);
    }
}

/**
 * AbstractChannel:
 * 第229行代码处：
 */
protected AbstractChannel(Channel parent) {
    this.parent = parent;
    id = newId();
    unsafe = newUnsafe();
    /*
    这里就可以看到对pipeline进行了初始化操作。也就是说，每一个NioServerSocketChannel
    或NioSocketChannel都会带有一个pipeline
     */
    pipeline = newChannelPipeline();
}

protected DefaultChannelPipeline newChannelPipeline() {
    return new DefaultChannelPipeline(this);
}

/**
 * DefaultChannelPipeline:
 */
protected DefaultChannelPipeline(Channel channel) {
    this.channel = ObjectUtil.checkNotNull(channel, "channel");
    succeededFuture = new SucceededChannelFuture(channel, null);
    voidPromise = new VoidChannelPromise(channel, true);

    /*
    这里可以看到初始化了pipeline中的head和tail的handler（HeadContext和TailContext本身就是
    一个ChannelHandler），而之后如果要加ChannelHandler的话，会在tail之前加入
     */
    tail = new TailContext(this);
    head = new HeadContext(this);

    //head和tail指针互相指向
    head.next = tail;
    tail.prev = head;
}

/**
 * ServerBootstrap:
 * 第96行代码处：
 */
@Override
void init(Channel channel) {
    setChannelOptions(channel, newOptionsArray(), logger);
    setAttributes(channel, attrs0().entrySet().toArray(EMPTY_ATTRIBUTE_ARRAY));

    //拿到之前在newChannelPipeline方法里面设置好的pipeline
    ChannelPipeline p = channel.pipeline();

    //拿到之前在group方法里面设置好的workerGroup
    final EventLoopGroup currentChildGroup = childGroup;
    //拿到之前在childHandler方法里面设置好的childHandler
    final ChannelHandler currentChildHandler = childHandler;
    final Map.Entry, Object>[] currentChildOptions;
    //我在之前没有演示，但是如果调用childOption方法，这里获取的就是childOptions
    synchronized (childOptions) {
        currentChildOptions = childOptions.entrySet().toArray(EMPTY_OPTION_ARRAY);
    }
    //我在之前没有演示，但是如果调用childAttr方法，这里获取的就是childAttrs
    final Map.Entry, Object>[] currentChildAttrs = childAttrs.entrySet().toArray(EMPTY_ATTRIBUTE_ARRAY);

    p.addLast(new ChannelInitializer() {
        @Override
        public void initChannel(final Channel ch) {
            final ChannelPipeline pipeline = ch.pipeline();
            ChannelHandler handler = config.handler();
            if (handler != null) {
                pipeline.addLast(handler);
            }

            ch.eventLoop().execute(new Runnable() {
                @Override
                public void run() {
                    pipeline.addLast(new ServerBootstrapAcceptor(
                            ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
                }
            });
        }
    });
}

/**
 * Bootstrap:
 * 第96行代码处：
 * （这里是客户端和服务端不一样的地方）
 */
@Override
@SuppressWarnings("unchecked")
void init(Channel channel) {
    ChannelPipeline p = channel.pipeline();
    p.addLast(config.handler());

    setChannelOptions(channel, newOptionsArray(), logger);
    setAttributes(channel, attrs0().entrySet().toArray(EMPTY_ATTRIBUTE_ARRAY));
}

/**
 * DefaultChannelPipeline:
 * 第311行和第340行代码处：
 * 可以看到服务端和客户端都调用了addLast方法，那么下面就来看一下其实现（以服务端来举例）
 */
@Override
public final ChannelPipeline addLast(ChannelHandler... handlers) {
    return addLast(null, handlers);
}

@Override
public final ChannelPipeline addLast(EventExecutorGroup executor, ChannelHandler... handlers) {
    ObjectUtil.checkNotNull(handlers, "handlers");

    for (ChannelHandler h : handlers) {
        if (h == null) {
            break;
        }
        addLast(executor, null, h);
    }

    return this;
}

/**
 * 第364行代码处：
 */
@Override
public final ChannelPipeline addLast(EventExecutorGroup group, String name, ChannelHandler handler) {
    final AbstractChannelHandlerContext newCtx;
    synchronized (this) {
        checkMultiplicity(handler);

        //把传进来的ChannelInitializer（服务端）封装为一个ChannelHandlerContext
        newCtx = newContext(group, filterName(name, handler), handler);

        addLast0(newCtx);

        if (!registered) {
            newCtx.setAddPending();
            callHandlerCallbackLater(newCtx, true);
            return this;
        }

        EventExecutor executor = newCtx.executor();
        if (!executor.inEventLoop()) {
            callHandlerAddedInEventLoop(newCtx, executor);
            return this;
        }
    }
    callHandlerAdded0(newCtx);
    return this;
}

/**
 * 第380行代码处：
 */
private AbstractChannelHandlerContext newContext(EventExecutorGroup group, String name, ChannelHandler handler) {
    return new DefaultChannelHandlerContext(this, childExecutor(group), name, handler);
}

/**
 * DefaultChannelHandlerContext:
 */
DefaultChannelHandlerContext(
        DefaultChannelPipeline pipeline, EventExecutor executor, String name, ChannelHandler handler) {
    super(pipeline, executor, name, handler.getClass());
    //这里就会将服务端的ChannelInitializer赋值进handler中，后面会用到
    this.handler = handler;
}

/**
 * 第382行代码处：
 * 从本方法就可以看出：新添加的ChannelHandlerContext会放在tail之前
 */
private void addLast0(AbstractChannelHandlerContext newCtx) {
    AbstractChannelHandlerContext prev = tail.prev;
    newCtx.prev = prev;
    newCtx.next = tail;
    prev.next = newCtx;
    tail.prev = newCtx;
}

/**
 * ServerBootstrap:
 * 第106行代码处：
 */
@Override
public final ServerBootstrapConfig config() {
    /*
    这里直接返回了config，而config的赋值在一开始创建ServerBootstrap时就已经创建好了，
    之前在分析ServerBootstrap的构造器中已经分析了这一点
     */
    return config;
}

/**
 * Bootstrap:
 * 第106行代码处：
 * （这里是客户端和服务端不一样的地方）
 */
@Override
public final BootstrapConfig config() {
    /*
    这里直接返回了config，而config的赋值在一开始创建Bootstrap时就已经创建好了，
    之前在分析Bootstrap的构造器中已经分析了这一点
     */
    return config;
}

/**
 * AbstractBootstrapConfig:
 * 第106行代码处：
 */
@SuppressWarnings("deprecation")
public final EventLoopGroup group() {
    //这里返回的就是ServerBootstrap或Bootstrap中的group方法
    return bootstrap.group();
}

/**
 * AbstractBootstrap:
 */
@Deprecated
public final EventLoopGroup group() {
    /*
    这里面的group就是之前在group方法中赋值的group，即bossGroup（服务端）
    或者是workerGroup（客户端）
     */
    return group;
}

/**
 * MultithreadEventLoopGroup:
 * 第106行代码处：
 */
@Override
public ChannelFuture register(Channel channel) {
    /*
    每调用一次本方法，就会用EventLoopGroup的下一个EventLoop来进行注册
    如果看过下面我对“next().register(channel)”这行代码的分析后就可以明白：
    这里实际上只会有一个线程来执行pipeline上的所有handler的事件，期间不会
    进行线程的切换，避免了锁竞争。这里也就是Netty中无锁串行化的体现
     */
    return next().register(channel);
}

@Override
public EventLoop next() {
    return (EventLoop) super.next();
}

/**
 * MultithreadEventExecutorGroup:
 */
@Override
public EventExecutor next() {
    /*
    在之前NioEventLoopGroup的构造器中，会根据executors的长度是否是2的幂来选择调用
    PowerOfTwoEventExecutorChooser或GenericEventExecutorChooser，也就是这里
    的chooser。此处会调用其next方法
     */
    return chooser.next();
}

/**
 * PowerOfTwoEventExecutorChooser(DefaultEventExecutorChooserFactory):
 */
@Override
public EventExecutor next() {
    /*
    executors也就是之前在NioEventLoopGroup的构造器中赋值进去的children。这里就是在拿取
    executors数组中的下一个EventExecutor。因为其长度为2的幂，所以可以用按位与的优化写法
    来同样达到取余的效果（在HashMap和ConcurrentHashMap中也出现了同样的取余优化写法）
     */
    return executors[idx.getAndIncrement() & executors.length - 1];
}

/**
 * GenericEventExecutorChooser(DefaultEventExecutorChooserFactory):
 */
@Override
public EventExecutor next() {
    /*
    同上面的解释，这里就是当executors的长度不是2的幂的时候，使用常规的“%”取余符号来进行拿取下一个
    EventExecutor的方式。之所以这里会取绝对值是为了防止出现数据溢出的情况：当idx递增到一个特别大
    的数：2147483647，那么此时再+1就变成了-2147483648，就变成了一个负数。而数组的索引位置
    是不可能出现负数的（如果为负数就会抛出数组索引越界异常），所以在这里会做一次取绝对值的操作
     */
    return executors[Math.abs(idx.getAndIncrement() % executors.length)];
}

/**
 * SingleThreadEventLoop:
 * 第490行代码处：
 */
@Override
public ChannelFuture register(Channel channel) {
    return register(new DefaultChannelPromise(channel, this));
}

@Override
public ChannelFuture register(final ChannelPromise promise) {
    ObjectUtil.checkNotNull(promise, "promise");
    promise.channel().unsafe().register(this, promise);
    return promise;
}

/**
 * AbstractChannel:
 */
@Override
public final void register(EventLoop eventLoop, final ChannelPromise promise) {
    ObjectUtil.checkNotNull(eventLoop, "eventLoop");
    if (isRegistered()) {
        promise.setFailure(new IllegalStateException("registered to an event loop already"));
        return;
    }
    if (!isCompatible(eventLoop)) {
        promise.setFailure(
                new IllegalStateException("incompatible event loop type: " + eventLoop.getClass().getName()));
        return;
    }

    //将SingleThreadEventLoop赋值给AbstractChannel.eventLoop
    AbstractChannel.this.eventLoop = eventLoop;

    if (eventLoop.inEventLoop()) {
        register0(promise);
    } else {
        try {
            eventLoop.execute(new Runnable() {
                @Override
                public void run() {
                    register0(promise);
                }
            });
        } catch (Throwable t) {
            logger.warn(
                    "Force-closing a channel whose registration task was not accepted by an event loop: {}",
                    AbstractChannel.this, t);
            closeForcibly();
            closeFuture.setClosed();
            safeSetFailure(promise, t);
        }
    }
}

/**
 * AbstractEventExecutor:
 * 第573行代码处：
 */
@Override
public boolean inEventLoop() {
    return inEventLoop(Thread.currentThread());
}

/**
 * SingleThreadEventExecutor:
 */
@Override
public boolean inEventLoop(Thread thread) {
    /*
    这里可以看到inEventLoop方法就是用来判断当前线程和SingleThreadEventExecutor中的线程是否是同一个
    而this.thread在此处还没有被赋值，为null，所以本方法返回false
     */
    return thread == this.thread;
}

/**
 * SingleThreadEventExecutor:
 * 第577行代码处：
 * 这里把register0方法的执行逻辑先放一放，先来看一下任务是如何被执行的
 */
@Override
public void execute(Runnable task) {
    ObjectUtil.checkNotNull(task, "task");
    execute(task, !(task instanceof LazyRunnable) && wakesUpForTask(task));
}

private void execute(Runnable task, boolean immediate) {
    //同上，inEventLoop方法此时返回false
    boolean inEventLoop = inEventLoop();
    addTask(task);
    if (!inEventLoop) {
        startThread();
        if (isShutdown()) {
            boolean reject = false;
            try {
                if (removeTask(task)) {
                    reject = true;
                }
            } catch (UnsupportedOperationException e) {
            }
            if (reject) {
                reject();
            }
        }
    }

    if (!addTaskWakesUp && immediate) {
        wakeup(inEventLoop);
    }
}

/**
 * 第629行代码处：
 */
protected void addTask(Runnable task) {
    ObjectUtil.checkNotNull(task, "task");
    if (!offerTask(task)) {
        reject(task);
    }
}

/**
 * 第656行代码处：
 */
final boolean offerTask(Runnable task) {
    if (isShutdown()) {
        reject();
    }
    //该处可以看到是把这个任务放到了任务队列（阻塞队列）中，在默认情况下容量为int的最大值。后续会执行它
    return taskQueue.offer(task);
}

/**
 * SingleThreadEventExecutor:
 * 第631行代码处：
 */
private void startThread() {
    if (state == ST_NOT_STARTED) {
        //CAS操作确保每一个NioEventLoop只会启动一个线程
        if (STATE_UPDATER.compareAndSet(this, ST_NOT_STARTED, ST_STARTED)) {
            boolean success = false;
            try {
                doStartThread();
                success = true;
            } finally {
                if (!success) {
                    STATE_UPDATER.compareAndSet(this, ST_STARTED, ST_NOT_STARTED);
                }
            }
        }
    }
}

/**
 * 第682行代码处：
 */
private void doStartThread() {
    assert thread == null;
    executor.execute(new Runnable() {
        @Override
        public void run() {
            //这里将this.thread赋值为当前线程，之后再调用inEventLoop方法就返回为true了
            thread = Thread.currentThread();
            if (interrupted) {
                thread.interrupt();
            }

            boolean success = false;
            updateLastExecutionTime();
            try {
                SingleThreadEventExecutor.this.run();
                success = true;
            } catch (Throwable t) {
                logger.warn("Unexpected exception from an event executor: ", t);
            } finally {
                for (; ; ) {
                    int oldState = state;
                    if (oldState >= ST_SHUTTING_DOWN || STATE_UPDATER.compareAndSet(
                            SingleThreadEventExecutor.this, oldState, ST_SHUTTING_DOWN)) {
                        break;
                    }
                }

                if (success && gracefulShutdownStartTime == 0) {
                    if (logger.isErrorEnabled()) {
                        logger.error("Buggy " + EventExecutor.class.getSimpleName() + " implementation; " +
                                SingleThreadEventExecutor.class.getSimpleName() + ".confirmShutdown() must " +
                                "be called before run() implementation terminates.");
                    }
                }

                try {
                    for (; ; ) {
                        if (confirmShutdown()) {
                            break;
                        }
                    }

                    for (; ; ) {
                        int oldState = state;
                        if (oldState >= ST_SHUTDOWN || STATE_UPDATER.compareAndSet(
                                SingleThreadEventExecutor.this, oldState, ST_SHUTDOWN)) {
                            break;
                        }
                    }

                    confirmShutdown();
                } finally {
                    try {
                        cleanup();
                    } finally {
                        FastThreadLocal.removeAll();

                        STATE_UPDATER.set(SingleThreadEventExecutor.this, ST_TERMINATED);
                        threadLock.countDown();
                        int numUserTasks = drainTasks();
                        if (numUserTasks > 0 && logger.isWarnEnabled()) {
                            logger.warn("An event executor terminated with " +
                                    "non-empty task queue (" + numUserTasks + ')');
                        }
                        terminationFuture.setSuccess(null);
                    }
                }
            }
        }
    });
}

/**
 * NioEventLoop:
 * 第710行代码处：
 * （注：以下的代码应该算是Netty中比较核心的代码了。但可惜的是，该代码的可读性非常差，嵌套了
 * 大量的try-catch和if-else。我查阅了该处代码的初始几次提交者是Trustin Lee（Netty原作者）
 * 和Norman Maurer，那个时候的run方法就已经嵌套了很多的if-else了-_-我能想到这里需要考虑
 * 很多复杂的场景，但是应该会有一种更好的实现方式）
 */
@Override
protected void run() {
    int selectCnt = 0;
    //这里的死循环也就是在Netty线程模型图中，NioEventLoop画圈循环执行的含义
    for (; ; ) {
        try {
            int strategy;
            try {
                strategy = selectStrategy.calculateStrategy(selectNowSupplier, hasTasks());
                //下面的代码就可以理解为在NIO编程中处理各种事件的代码
                switch (strategy) {
                    case SelectStrategy.CONTINUE:
                        continue;

                    case SelectStrategy.BUSY_WAIT:

                    case SelectStrategy.SELECT:
                        long curDeadlineNanos = nextScheduledTaskDeadlineNanos();
                        if (curDeadlineNanos == -1L) {
                            curDeadlineNanos = NONE;
                        }
                        nextWakeupNanos.set(curDeadlineNanos);
                        try {
                            if (!hasTasks()) {
                                strategy = select(curDeadlineNanos);
                            }
                        } finally {
                            nextWakeupNanos.lazySet(AWAKE);
                        }
                    default:
                }
            } catch (IOException e) {
                rebuildSelector0();
                selectCnt = 0;
                handleLoopException(e);
                continue;
            }

            selectCnt++;
            cancelledKeys = 0;
            needsToSelectAgain = false;
            final int ioRatio = this.ioRatio;
            boolean ranTasks;
            if (ioRatio == 100) {
                try {
                    if (strategy > 0) {
                        processSelectedKeys();
                    }
                } finally {
                    ranTasks = runAllTasks();
                }
            } else if (strategy > 0) {
                final long ioStartTime = System.nanoTime();
                try {
                    processSelectedKeys();
                } finally {
                    final long ioTime = System.nanoTime() - ioStartTime;
                    ranTasks = runAllTasks(ioTime * (100 - ioRatio) / ioRatio);
                }
            } else {
                ranTasks = runAllTasks(0);
            }

            if (ranTasks || strategy > 0) {
                if (selectCnt > MIN_PREMATURE_SELECTOR_RETURNS && logger.isDebugEnabled()) {
                    logger.debug("Selector.select() returned prematurely {} times in a row for Selector {}.",
                            selectCnt - 1, selector);
                }
                selectCnt = 0;
            } else if (unexpectedSelectorWakeup(selectCnt)) {
                selectCnt = 0;
            }
        } catch (CancelledKeyException e) {
            if (logger.isDebugEnabled()) {
                logger.debug(CancelledKeyException.class.getSimpleName() + " raised by a Selector {} - JDK bug?",
                        selector, e);
            }
        } catch (Throwable t) {
            handleLoopException(t);
        }
        try {
            if (isShuttingDown()) {
                closeAll();
                if (confirmShutdown()) {
                    return;
                }
            }
        } catch (Throwable t) {
            handleLoopException(t);
        }
    }
}

/**
 * 第800行代码处：
 * 这里也就是在Netty线程模型图中NioEventLoop循环所做的第一件事：select
 */
private int select(long deadlineNanos) throws IOException {
    if (deadlineNanos == NONE) {
        /*
        可以看到这里就是在调用NIO编程中的select方法，如果没有客户端来的时候，本方法会一直阻塞在这里
        （从这里又可以再一次看出：Netty就是对NIO的一种复杂封装，但是使用起来会很简单）
         */
        return selector.select();
    }
    long timeoutMillis = deadlineToDelayNanos(deadlineNanos + 995000L) / 1000000L;
    //这里会调用NIO编程中有时间限制的select方法
    return timeoutMillis <= 0 ? selector.selectNow() : selector.select(timeoutMillis);
}

/**
 * 第822行和第830行代码处：
 * 这里也就是在Netty线程模型图中NioEventLoop循环所做的第二件事：processSelectedKeys
 * 跟NIO编程一样，如果有事件来临的时候，会把该事件放在selectedKeys集合中，也就会执行本方法
 * 如果没有事件来临，该方法不会被调用
 * （注：我建议processSelectedKey方法放在最后再看、等服务端走完所有的流程后再看比较好
 * 现在可以先过掉这个方法，直接去看第三件事：runAllTasks方法的实现。因为processSelectedKey
 * 方法本身就是服务端初始化完成后，客户端发起事件时才会调用的方法。如果现在就看下面的分析的话，
 * 可能有些东西会不理解（我下面对processSelectedKeys方法的分析也是建立在看完了服务端所有初始化
 * 流程后的基础上，再进行分析的））
 */
private void processSelectedKeys() {
    /*
    在之前NioEventLoopGroup的构造器中，已经对selectedKeys进行了初始化，所以这里会走
    processSelectedKeysOptimized方法中
     */
    if (selectedKeys != null) {
        processSelectedKeysOptimized();
    } else {
        processSelectedKeysPlain(selector.selectedKeys());
    }
}

/**
 * 第903行代码处：
 */
private void processSelectedKeysOptimized() {
    for (int i = 0; i < selectedKeys.size; ++i) {
        //处理集合中的每一个selectedKey
        final SelectionKey k = selectedKeys.keys[i];
        selectedKeys.keys[i] = null;

        final Object a = k.attachment();

        if (a instanceof AbstractNioChannel) {
            processSelectedKey(k, (AbstractNioChannel) a);
        } else {
            @SuppressWarnings("unchecked")
            NioTask task = (NioTask) a;
            processSelectedKey(k, task);
        }

        if (needsToSelectAgain) {
            selectedKeys.reset(i + 1);

            selectAgain();
            i = -1;
        }
    }
}

/**
 * 第921行代码处：
 */
private void processSelectedKey(SelectionKey k, AbstractNioChannel ch) {
    final AbstractNioChannel.NioUnsafe unsafe = ch.unsafe();
    if (!k.isValid()) {
        final EventLoop eventLoop;
        try {
            eventLoop = ch.eventLoop();
        } catch (Throwable ignored) {
            return;
        }
        if (eventLoop == this) {
            unsafe.close(unsafe.voidPromise());
        }
        return;
    }

    try {
        int readyOps = k.readyOps();
        //处理OP_CONNECT事件
        if ((readyOps & SelectionKey.OP_CONNECT) != 0) {
            int ops = k.interestOps();
            ops &= ~SelectionKey.OP_CONNECT;
            k.interestOps(ops);

            unsafe.finishConnect();
        }

        //处理OP_WRITE事件
        if ((readyOps & SelectionKey.OP_WRITE) != 0) {
            ch.unsafe().forceFlush();
        }

        //处理OP_READ或OP_ACCEPT事件
        if ((readyOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0) {
            /*
            这里来着重研究一下read方法（OP_ACCEPT事件是客户端连接服务端传来的事件，
            而OP_READ表示服务端和客户端收到彼此传来的读事件）
             */
            unsafe.read();
        }
    } catch (CancelledKeyException ignored) {
        unsafe.close(unsafe.voidPromise());
    }
}

/**
 * AbstractNioMessageChannel:
 * 第977行代码处：
 * 假设当前是客户端连接服务端传来的OP_ACCEPT事件
 */
@Override
public void read() {
    assert eventLoop().inEventLoop();
    final ChannelConfig config = config();
    /*
    重点：这里获取到的pipeline是NioServerSocketChannel的pipeline，
    也就是在之前第323行和第1682行代码处，往这个pipeline中添加了ServerBootstrapAcceptor
     */
    final ChannelPipeline pipeline = pipeline();
    final RecvByteBufAllocator.Handle allocHandle = unsafe().recvBufAllocHandle();
    allocHandle.reset(config);

    boolean closed = false;
    Throwable exception = null;
    try {
        try {
            do {
                int localRead = doReadMessages(readBuf);
                if (localRead == 0) {
                    break;
                }
                if (localRead < 0) {
                    closed = true;
                    break;
                }

                allocHandle.incMessagesRead(localRead);
            } while (allocHandle.continueReading());
        } catch (Throwable t) {
            exception = t;
        }

        int size = readBuf.size();
        for (int i = 0; i < size; i++) {
            readPending = false;
            pipeline.fireChannelRead(readBuf.get(i));
        }
        readBuf.clear();
        allocHandle.readComplete();
        pipeline.fireChannelReadComplete();

        if (exception != null) {
            closed = closeOnReadError(exception);

            pipeline.fireExceptionCaught(exception);
        }

        if (closed) {
            inputShutdown = true;
            if (isOpen()) {
                close(voidPromise());
            }
        }
    } finally {
        if (!readPending && !config.isAutoRead()) {
            removeReadOp();
        }
    }
}

/**
 * NioServerSocketChannel:
 * 第1006行代码处：
 */
@Override
protected int doReadMessages(List buf) throws Exception {
    SocketChannel ch = SocketUtils.accept(javaChannel());

    try {
        if (ch != null) {
            /*
            把当前客户端的NioSocketChannel加入到readBuf中（之前分析过，NioSocketChannel
            构造器中会把OP_READ事件赋值进去，并且配置为非阻塞）
             */
            buf.add(new NioSocketChannel(this, ch));
            return 1;
        }
    } catch (Throwable t) {
        logger.warn("Failed to create a new channel from an accepted socket.", t);

        try {
            ch.close();
        } catch (Throwable t2) {
            logger.warn("Failed to close a socket.", t2);
        }
    }

    return 0;
}

/**
 * SocketUtils:
 * 第1055行代码处：
 */
public static SocketChannel accept(final ServerSocketChannel serverSocketChannel) throws IOException {
    try {
        return AccessController.doPrivileged(new PrivilegedExceptionAction() {
            @Override
            public SocketChannel run() throws IOException {
                /*
                这里也就是在NIO编程中，ServerSocketChannel调用accept方法
                调用完之后，客户端的channel就已经连接起来了
                 */
                return serverSocketChannel.accept();
            }
        });
    } catch (PrivilegedActionException e) {
        throw (IOException) e.getCause();
    }
}

/**
 * DefaultChannelPipeline:
 * 第1024行代码处：
 */
@Override
public final ChannelPipeline fireChannelRead(Object msg) {
    AbstractChannelHandlerContext.invokeChannelRead(head, msg);
    return this;
}

/**
 * AbstractChannelHandlerContext:
 */
static void invokeChannelRead(final AbstractChannelHandlerContext next, Object msg) {
    final Object m = next.pipeline.touch(ObjectUtil.checkNotNull(msg, "msg"), next);
    EventExecutor executor = next.executor();
    //同上，inEventLoop方法会返回true
    if (executor.inEventLoop()) {
        next.invokeChannelRead(m);
    } else {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                next.invokeChannelRead(m);
            }
        });
    }
}

/**
 * 第1118行代码处：
 */
private void invokeChannelRead(Object msg) {
    if (invokeHandler()) {
        try {
            //这里也就是在执行每一个inboundHandler的read事件（以下以HeadContext为例来看一下执行过程）
            ((ChannelInboundHandler) handler()).channelRead(this, msg);
        } catch (Throwable t) {
            invokeExceptionCaught(t);
        }
    } else {
        fireChannelRead(msg);
    }
}

/**
 * DefaultChannelPipeline:
 * 第1136行代码处：
 */
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) {
    //可以看到HeadContext的channelRead事件没有做什么事，只是调用了下一个handler的channelRead事件
    ctx.fireChannelRead(msg);
}

/**
 * AbstractChannelHandlerContext:
 */
@Override
public ChannelHandlerContext fireChannelRead(final Object msg) {
    /*
    如上面对pipeline的解释，这里拿到的下一个inboundHandler其实是之前添加的ServerBootstrapAcceptor，
    所以接下来就来看一下它的channelRead的实现
     */
    invokeChannelRead(findContextInbound(MASK_CHANNEL_READ), msg);
    return this;
}

/**
 * ServerBootstrap:
 */
@Override
@SuppressWarnings("unchecked")
public void channelRead(ChannelHandlerContext ctx, Object msg) {
    //这里传进来的msg就是上面第1063行代码处赋值进去的NioSocketChannel
    final Channel child = (Channel) msg;

    /*
    addLast方法之前已经分析过了，这里也就是把我们在服务端自定义的childHandler
    放到了NioSocketChannel的pipeline中
     */
    child.pipeline().addLast(childHandler);

    setChannelOptions(child, childOptions, logger);
    setAttributes(child, childAttrs);

    try {
        /*
        这里的register方法非常重要（之前已经分析过该方法的实现了），这里的作用也就是注册
        NioSocketChannel到workerGroup的selector上，同时开启一个线程在select方法处被阻塞，
        后续客户端的读写事件都会交由workerGroup来进行处理。也就是在Netty线程模型图中，
        bossGroup和workerGroup中间连接的那条线的含义

        同时，在之前register方法的分析中，我们知道它最终会回调我们自定义childHandler中的
        ChannelInitializer中的的initChannel方法：也就是将我们自己写的所有handler都放到
        workerGroup的pipeline中
         */
        childGroup.register(child).addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                if (!future.isSuccess()) {
                    forceClose(child, future.cause());
                }
            }
        });
    } catch (Throwable t) {
        forceClose(child, t);
    }
}

/**
 * AbstractNioByteChannel:
 * 第977行代码处：
 * 当执行完AbstractNioMessageChannel的read方法后，也就是客户端和服务端成功连接上了之后，
 * 这个时候如果客户端有事件来临的时候，就会触发OP_READ事件，也就是会调用本方法
 */
@Override
public final void read() {
    final ChannelConfig config = config();
    if (shouldBreakReadReady(config)) {
        clearReadPending();
        return;
    }
    //同上面的解释，这个时候拿到的pipeline就是workerGroup的pipeline，也就是里面装载着我们自己写的handler
    final ChannelPipeline pipeline = pipeline();
    final ByteBufAllocator allocator = config.getAllocator();
    final RecvByteBufAllocator.Handle allocHandle = recvBufAllocHandle();
    allocHandle.reset(config);

    ByteBuf byteBuf = null;
    boolean close = false;
    try {
        do {
            //分配一个直接内存byteBuf
            byteBuf = allocHandle.allocate(allocator);
            //byteBuf此时就存着客户端写过来的数据
            allocHandle.lastBytesRead(doReadBytes(byteBuf));
            if (allocHandle.lastBytesRead() <= 0) {
                byteBuf.release();
                byteBuf = null;
                close = allocHandle.lastBytesRead() < 0;
                if (close) {
                    readPending = false;
                }
                break;
            }

            allocHandle.incMessagesRead(1);
            readPending = false;
            /*
            此时就会拿着客户端写过来的数据在服务端我们自定义的handler中，遍历地去执行channelRead方法
            至此整个流程就打通了
             */
            pipeline.fireChannelRead(byteBuf);
            byteBuf = null;
        } while (allocHandle.continueReading());

        allocHandle.readComplete();
        //fireChannelRead方法执行完毕后，会遍历去执行channelReadComplete方法
        pipeline.fireChannelReadComplete();

        if (close) {
            closeOnRead(pipeline);
        }
    } catch (Throwable t) {
        handleReadException(pipeline, byteBuf, t, close, allocHandle);
    } finally {
        if (!readPending && !config.isAutoRead()) {
            removeReadOp();
        }
    }
}

/**
 * SingleThreadEventExecutor:
 * 第825行代码处：
 * 这里也就是在Netty线程模型图中NioEventLoop循环所做的第三件事：runAllTasks，也就是执行taskQueue中的任务
 */
protected boolean runAllTasks() {
    assert inEventLoop();
    boolean fetchedAll;
    boolean ranAtLeastOne = false;

    //do-while循环确保执行完所有taskQueue中的任务
    do {
        fetchedAll = fetchFromScheduledTaskQueue();
        //执行taskQueue中的所有任务
        if (runAllTasksFrom(taskQueue)) {
            ranAtLeastOne = true;
        }
    } while (!fetchedAll);

    if (ranAtLeastOne) {
        lastExecutionTime = ScheduledFutureTask.nanoTime();
    }
    //钩子方法，空实现
    afterRunningAllTasks();
    return ranAtLeastOne;
}

/**
 * SingleThreadEventExecutor:
 * 第833行和第836行代码处：
 * 这里也就是在Netty线程模型图中NioEventLoop循环所做的第三件事：runAllTasks，也就是执行taskQueue中的任务
 * （本方法是上面方法的重载方法，需要考虑定时任务超时的问题）
 * （注：这两个方法为什么不考虑封装成一个公有的抽象，然后使用类似模板方法模式来进行不同的实现？）
 */
protected boolean runAllTasks(long timeoutNanos) {
    fetchFromScheduledTaskQueue();
    Runnable task = pollTask();
    if (task == null) {
        //钩子方法，空实现
        afterRunningAllTasks();
        return false;
    }

    final long deadline = timeoutNanos > 0 ? ScheduledFutureTask.nanoTime() + timeoutNanos : 0;
    long runTasks = 0;
    long lastExecutionTime;
    for (; ; ) {
        safeExecute(task);

        runTasks++;

        //每执行64个任务后获取一下当前时间，看是否已经超时了（因为nanoTime的获取也会有消耗，所以不是一个任务一次调用）
        if ((runTasks & 0x3F) == 0) {
            lastExecutionTime = ScheduledFutureTask.nanoTime();
            if (lastExecutionTime >= deadline) {
                break;
            }
        }

        task = pollTask();
        if (task == null) {
            lastExecutionTime = ScheduledFutureTask.nanoTime();
            break;
        }
    }

    //钩子方法，空实现
    afterRunningAllTasks();
    this.lastExecutionTime = lastExecutionTime;
    return true;
}

/**
 * 第1285行和第1308行代码处：
 * 这里需要说一下前提：除了taskQueue之外还有一个scheduledTaskQueue的定时任务队列。当taskQueue存满了的时候，
 * 会将剩下的任务存放进scheduledTaskQueue中。所以本方法的执行，达到的效果就是取出scheduledTaskQueue中的
 * 任务再放回到taskQueue，直到taskQueue再次存满为止
 */
private boolean fetchFromScheduledTaskQueue() {
    //如果scheduledTaskQueue本身就是空的，就直接返回true
    if (scheduledTaskQueue == null || scheduledTaskQueue.isEmpty()) {
        return true;
    }
    long nanoTime = AbstractScheduledEventExecutor.nanoTime();
    for (; ; ) {
        //从scheduledTaskQueue中拿走队头任务
        Runnable scheduledTask = pollScheduledTask(nanoTime);
        //如果scheduledTask是空的，说明scheduledTaskQueue中已经没有了任务（或者超时了），就直接返回true
        if (scheduledTask == null) {
            return true;
        }
        if (!taskQueue.offer(scheduledTask)) {
            /*
            将从scheduledTaskQueue中拿出的任务再次放到taskQueue中，循环这一过程。如果taskQueue满了放不下的话，
            就把这一次拿出的任务再次放回到scheduledTaskQueue中，并返回false
             */
            scheduledTaskQueue.add((ScheduledFutureTask) scheduledTask);
            return false;
        }
    }
}

/**
 * AbstractScheduledEventExecutor:
 * 第1359行代码处：
 * 从scheduledTaskQueue中拿走队头任务
 */
protected final Runnable pollScheduledTask(long nanoTime) {
    assert inEventLoop();

    ScheduledFutureTask scheduledTask = peekScheduledTask();
    if (scheduledTask == null || scheduledTask.deadlineNanos() - nanoTime > 0) {
        return null;
    }
    //如果peek获取的任务不为空或者没超时，就删除掉它，相当于拿走队头任务了
    scheduledTaskQueue.remove();
    scheduledTask.setConsumed();
    return scheduledTask;
}

/**
 * 第1383行代码处：
 */
final ScheduledFutureTask peekScheduledTask() {
    Queue> scheduledTaskQueue = this.scheduledTaskQueue;
    //从scheduledTaskQueue中获取队头任务
    return scheduledTaskQueue != null ? scheduledTaskQueue.peek() : null;
}

/**
 * SingleThreadEventExecutor:
 * 第1287行代码处：
 */
protected final boolean runAllTasksFrom(Queue taskQueue) {
    //拿取taskQueue中的一个任务
    Runnable task = pollTaskFrom(taskQueue);
    //如果任务为null，就直接返回false，说明此时taskQueue中已经没有任务了，也就不需要执行了
    if (task == null) {
        return false;
    }
    for (; ; ) {
        //执行任务
        safeExecute(task);
        //执行完一个任务后继续拿取taskQueue中的下一个任务去执行，死循环确保重复这一过程
        task = pollTaskFrom(taskQueue);
        //如果任务为null，就直接返回true，说明此时taskQueue中已经没有任务了
        if (task == null) {
            return true;
        }
    }
}

/**
 * 第1309行和第1332行代码处：
 */
protected Runnable pollTask() {
    assert inEventLoop();
    return pollTaskFrom(taskQueue);
}

/**
 * 第1408行、第1417行和第1430行代码处：
 */
protected static Runnable pollTaskFrom(Queue taskQueue) {
    for (; ; ) {
        //拿走taskQueue中的队头任务，如果为空任务就继续拿取下一个，直到不为空为止
        Runnable task = taskQueue.poll();
        if (task != WAKEUP_TASK) {
            return task;
        }
    }
}

/**
 * AbstractEventExecutor:
 * 第1320行和第1415行代码处：
 */
protected static void safeExecute(Runnable task) {
    try {
        /*
        这里也就是在真正执行任务的地方。现在已经搞清楚了任务是如何启动去执行的，而之前在register注册的时候
        放入了一个注册任务，那么下面就来看一下这个任务具体的执行代码
         */
        task.run();
    } catch (Throwable t) {
        logger.warn("A task raised an exception. Task: {}", task, t);
    }
}

/**
 * AbstractChannel:
 * 第580行代码处：
 */
private void register0(ChannelPromise promise) {
    try {
        if (!promise.setUncancellable() || !ensureOpen(promise)) {
            return;
        }
        boolean firstRegistration = neverRegistered;
        doRegister();
        neverRegistered = false;
        registered = true;

        pipeline.invokeHandlerAddedIfNeeded();

        safeSetSuccess(promise);
        pipeline.fireChannelRegistered();
        if (isActive()) {
            if (firstRegistration) {
                pipeline.fireChannelActive();
            } else if (config().isAutoRead()) {
                beginRead();
            }
        }
    } catch (Throwable t) {
        closeForcibly();
        closeFuture.setClosed();
        safeSetFailure(promise, t);
    }
}

/**
 * AbstractNioChannel:
 * 第1472行代码处：
 */
@Override
protected void doRegister() throws Exception {
    boolean selected = false;
    for (; ; ) {
        try {
            //这行话其实就对应于NIO编程中把ServerSocketChannel或SocketChannel注册到selector上
            selectionKey = javaChannel().register(eventLoop().unwrappedSelector(), 0, this);
            return;
        } catch (CancelledKeyException e) {
            if (!selected) {
                eventLoop().selectNow();
                selected = true;
            } else {
                throw e;
            }
        }
    }
}

/**
 * DefaultChannelPipeline:
 * 第1476行代码处：
 */
final void invokeHandlerAddedIfNeeded() {
    assert channel.eventLoop().inEventLoop();
    if (firstRegistration) {
        firstRegistration = false;
        //之前说过，当channel被注册时会回调initChannel方法，所以这里就是在做这件事
        callHandlerAddedForAllHandlers();
    }
}

private void callHandlerAddedForAllHandlers() {
    final PendingHandlerCallback pendingHandlerCallbackHead;
    synchronized (this) {
        assert !registered;

        registered = true;

        pendingHandlerCallbackHead = this.pendingHandlerCallbackHead;
        this.pendingHandlerCallbackHead = null;
    }

    PendingHandlerCallback task = pendingHandlerCallbackHead;
    while (task != null) {
        task.execute();
        task = task.next;
    }
}

/**
 * 第1543行代码处：
 */
@Override
void execute() {
    EventExecutor executor = ctx.executor();
    //inEventLoop方法在之前第702行代码处的doStartThread方法里面已经对thread赋值成当前线程了，所以这里肯定返回true
    if (executor.inEventLoop()) {
        callHandlerAdded0(ctx);
    } else {
        try {
            executor.execute(this);
        } catch (RejectedExecutionException e) {
            if (logger.isWarnEnabled()) {
                logger.warn(
                        "Can't invoke handlerAdded() as the EventExecutor {} rejected it, removing handler {}.",
                        executor, ctx.name(), e);
            }
            atomicRemoveFromHandlerList(ctx);
            ctx.setRemoved();
        }
    }
}

/**
 * 第1556行代码处：
 */
private void callHandlerAdded0(final AbstractChannelHandlerContext ctx) {
    try {
        ctx.callHandlerAdded();
    } catch (Throwable t) {
        boolean removed = false;
        try {
            atomicRemoveFromHandlerList(ctx);
            ctx.callHandlerRemoved();
            removed = true;
        } catch (Throwable t2) {
            if (logger.isWarnEnabled()) {
                logger.warn("Failed to remove a handler: " + ctx.name(), t2);
            }
        }

        if (removed) {
            fireExceptionCaught(new ChannelPipelineException(
                    ctx.handler().getClass().getName() +
                            ".handlerAdded() has thrown an exception; removed.", t));
        } else {
            fireExceptionCaught(new ChannelPipelineException(
                    ctx.handler().getClass().getName() +
                            ".handlerAdded() has thrown an exception; also failed to remove.", t));
        }
    }
}

/**
 * AbstractChannelHandlerContext:
 * 第1577行代码处：
 */
final void callHandlerAdded() throws Exception {
    if (setAddComplete()) {
        /*
        这里获取的handler正是之前第414行代码处，调用DefaultChannelHandlerContext构造器
        赋值进去的ChannelInitializer
         */
        handler().handlerAdded(this);
    }
}

/**
 * ChannelInitializer:
 */
@Override
public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
    if (ctx.channel().isRegistered()) {
        if (initChannel(ctx)) {

            removeState(ctx);
        }
    }
}

/**
 * 第1622行代码处：
 */
@SuppressWarnings("unchecked")
private boolean initChannel(ChannelHandlerContext ctx) throws Exception {
    if (initMap.add(ctx)) {
        try {
            //这里就是回调之前在第313行代码处的initChannel方法，下面就来看一下该方法的实现过程
            initChannel((C) ctx.channel());
        } catch (Throwable cause) {
            exceptionCaught(ctx, cause);
        } finally {
            ChannelPipeline pipeline = ctx.pipeline();
            //这里就可以看到当执行完initChannel方法后会删除当前ChannelInitializer实例
            if (pipeline.context(this) != null) {
                pipeline.remove(this);
            }
        }
        return true;
    }
    return false;
}

/**
 * ServerBootstrap:
 * 第313行代码处：
 * 为了延续一路分析下来的顺序，这里将之前initChannel回调方法的具体代码重新拷贝了一份放在下面，
 * 以此来连贯分析其具体执行过程
 */
@Override
public void initChannel(final Channel ch) {
    final ChannelPipeline pipeline = ch.pipeline();
    //因为我们之前调用ServerBootstrap和Bootstrap的构造器都是空实现，所以这里获取到的handler也是null
    ChannelHandler handler = config.handler();
    if (handler != null) {
        pipeline.addLast(handler);
    }

    /*
    这里又调用了一次execute方法，将任务放到taskQueue中，然后等待runAllTasks方法去执行
    之前在第621行代码处已经分析了其具体执行过程，这里就不再次重复分析了
     */
    ch.eventLoop().execute(new Runnable() {
        @Override
        public void run() {
            /*
            addLast方法在之前的第352行代码处也已经分析过了，将ChannelHandler添加进pipeline中
            只不过之前添加的是ChannelInitializer，而这里添加的是ServerBootstrapAcceptor
            （添加之后ChannelInitializer的initChannel方法就走完了，然后在上面的第1644行代码处
            可以看到，会从pipeline中删除当前ChannelInitializer实例，所以目前服务端的pipeline
            中除了tail和head之外，就只剩下了ServerBootstrapAcceptor（需要注意的是：添加
            ServerBootstrapAcceptor是在另一个线程中完成的，主线程不一定能及时感知到这个变化））
             */
            pipeline.addLast(new ServerBootstrapAcceptor(
                    ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
        }
    });
    /*
    目前这条线就算是走完了，再来回到最开始的地方，即第1476行代码处.我们刚才所有的分析都是从
    invokeHandlerAddedIfNeeded方法里面进行展开的，现在该方法走完了，就继续走接下来的代码
     */
}

/**
 * DefaultChannelPipeline:
 * 第1479行代码处：
 * 该方法实现的就是通过遍历pipeline中的每一个inboundHandler，执行其channelRegistered方法
 */
@Override
public final ChannelPipeline fireChannelRegistered() {
    AbstractChannelHandlerContext.invokeChannelRegistered(head);
    return this;
}

/**
 * AbstractChannelHandlerContext:
 */
static void invokeChannelRegistered(final AbstractChannelHandlerContext next) {
    EventExecutor executor = next.executor();
    //同上，inEventLoop方法会返回true
    if (executor.inEventLoop()) {
        next.invokeChannelRegistered();
    } else {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                next.invokeChannelRegistered();
            }
        });
    }
}

/**
 * 第1710行代码处：
 */
private void invokeChannelRegistered() {
    //该方法返回true
    if (invokeHandler()) {
        try {
            ((ChannelInboundHandler) handler()).channelRegistered(this);
        } catch (Throwable t) {
            invokeExceptionCaught(t);
        }
    } else {
        fireChannelRegistered();
    }
}

/**
 * DefaultChannelPipeline:
 * 第1728行代码处：
 * 因为传进来的是head，所以这里调用的是HeadContext的channelRegistered方法
 */
@Override
public void channelRegistered(ChannelHandlerContext ctx) {
    /*
    invokeHandlerAddedIfNeeded方法之前已经分析过了，但是这里并不会具体执行后续的
    callHandlerAddedForAllHandlers，因为在之前的调用过程中已经把firstRegistration
    置为false了，详见第1524行代码处。所以这里不会再调用了，相当于是个空方法
     */
    invokeHandlerAddedIfNeeded();
    /*
    这里是调用下一个inboundHandler的channelRegistered方法。如果是TailContext的话，就会去执行
    它的channelRegistered方法。但是TailContext的channelRegistered方法是一个空实现，所以这里
    就不再具体展开分析了，调用的流程都是和HeadContext类似的
     */
    ctx.fireChannelRegistered();
}

/**
 * AbstractChannelHandlerContext:
 * 第1755行代码处：
 */
@Override
public ChannelHandlerContext fireChannelRegistered() {
    /*
    因为这里是调用channelRegistered事件，站在服务端的角度来说相当于入站事件
    所以当通过findContextInbound方法拿到下一个inboundHandler时候，就调用
    它的channelRegistered方法
     */
    invokeChannelRegistered(findContextInbound(MASK_CHANNEL_REGISTERED));
    return this;
}

/**
 * 该方法就是用来找到下一个执行注册动作的inboundHandler
 */
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;
}

/**
 * 如果返回true，则代表当前handler是需要跳过的。比如当前需要剔除outBoundHandler，那么传进来的
 * onlyMask就是MASK_ONLY_INBOUND，当遇到一个outBoundHandler的时候，本方法就会返回true；
 * 当遇到一个inboundHandler的时候，本方法就会返回false
 */
private static boolean skipContext(
        AbstractChannelHandlerContext ctx, EventExecutor currentExecutor, int mask, int onlyMask) {
    return (ctx.executionMask & (onlyMask | mask)) == 0 ||
            (ctx.executor() == currentExecutor && (ctx.executionMask & mask) == 0);
}

/**
 * AbstractBootstrap:
 * 第14行代码处：
 * 上面所有的分析都是在分析initAndRegister这个方法，现在我们来接着分析在这之后的代码，
 * 首先是服务端的doBind方法。为了延续一路分析下来的顺序，这里将之前doBind方法的具体代码
 * 重新拷贝了一份放在下面，以此来连贯分析其具体执行过程
 */
private ChannelFuture doBind(final SocketAddress localAddress) {
    //之前已经分析了initAndRegister方法的具体执行过程
    final ChannelFuture regFuture = initAndRegister();
    final Channel channel = regFuture.channel();
    if (regFuture.cause() != null) {
        return regFuture;
    }

    //该方法会返回false
    if (regFuture.isDone()) {
        ChannelPromise promise = channel.newPromise();
        doBind0(regFuture, channel, localAddress, promise);
        return promise;
    } else {
        final PendingRegistrationPromise promise = new PendingRegistrationPromise(channel);
        regFuture.addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                Throwable cause = future.cause();
                if (cause != null) {
                    promise.setFailure(cause);
                } else {
                    promise.registered();

                    //这里也就是在做绑定端口的工作
                    doBind0(regFuture, channel, localAddress, promise);
                }
            }
        });
        return promise;
    }
}

/**
 * AbstractBootstrap:
 */
private static void doBind0(
        final ChannelFuture regFuture, final Channel channel,
        final SocketAddress localAddress, final ChannelPromise promise) {

    //之前已经分析过了，看到“eventLoop().execute”这行代码就知道是创建了一个新任务放到了taskQueue中
    channel.eventLoop().execute(new Runnable() {
        @Override
        public void run() {
            if (regFuture.isSuccess()) {
                channel.bind(localAddress, promise).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
            } else {
                promise.setFailure(regFuture.cause());
            }
        }
    });
}

/**
 * AbstractChannel:
 * 第1848行代码处：
 */
@Override
public ChannelFuture bind(SocketAddress localAddress, ChannelPromise promise) {
    /*
    其实这里和channelRegistered事件的执行过程是类似的，都是遍历handler去执行事件，
    但是这里是从tail到head的顺序找出outboundHandler
     */
    return pipeline.bind(localAddress, promise);
}

/**
 * DefaultChannelPipeline:
 */
@Override
public final ChannelFuture bind(SocketAddress localAddress, ChannelPromise promise) {
    return tail.bind(localAddress, promise);
}

/**
 * AbstractChannelHandlerContext:
 */
@Override
public ChannelFuture bind(final SocketAddress localAddress, final ChannelPromise promise) {
    ObjectUtil.checkNotNull(localAddress, "localAddress");
    if (isNotValidPromise(promise, false)) {
        return promise;
    }

    //这里就是在找下一个执行绑定动作的outboundHandler
    final AbstractChannelHandlerContext next = findContextOutbound(MASK_BIND);
    EventExecutor executor = next.executor();
    //同之前的分析，该方法会返回true
    if (executor.inEventLoop()) {
        next.invokeBind(localAddress, promise);
    } else {
        safeExecute(executor, new Runnable() {
            @Override
            public void run() {
                next.invokeBind(localAddress, promise);
            }
        }, promise, null, false);
    }
    return promise;
}

/**
 * 第1888行代码处：
 * 该方法的代码和findContextInbound方法代码之间的区别除了onlyMask不同之外，还有一点就是
 * findContextInbound方法中是从head到tail依次遍历的；而findContextOutbound方法也就是
 * 本方法中是从tail到head依次遍历的
 */
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;
}

/**
 * 第1892行代码处：
 */
private void invokeBind(SocketAddress localAddress, ChannelPromise promise) {
    if (invokeHandler()) {
        try {
            //这里也就是在执行每一个outboundHandler的bind事件（以下以HeadContext为例来看一下执行过程）
            ((ChannelOutboundHandler) handler()).bind(this, localAddress, promise);
        } catch (Throwable t) {
            notifyOutboundHandlerException(t, promise);
        }
    } else {
        bind(localAddress, promise);
    }
}

/**
 * DefaultChannelPipeline:
 * 第1926行代码处：
 */
@Override
public void bind(
        ChannelHandlerContext ctx, SocketAddress localAddress, ChannelPromise promise) {
    unsafe.bind(localAddress, promise);
}

/**
 * AbstractChannel:
 */
@Override
public final void bind(final SocketAddress localAddress, final ChannelPromise promise) {
    assertEventLoop();

    if (!promise.setUncancellable() || !ensureOpen(promise)) {
        return;
    }

    if (Boolean.TRUE.equals(config().getOption(ChannelOption.SO_BROADCAST)) &&
            localAddress instanceof InetSocketAddress &&
            !((InetSocketAddress) localAddress).getAddress().isAnyLocalAddress() &&
            !PlatformDependent.isWindows() && !PlatformDependent.maybeSuperUser()) {
        logger.warn(
                "A non-root user can't receive a broadcast packet if the socket " +
                        "is not bound to a wildcard address; binding to a non-wildcard " +
                        "address (" + localAddress + ") anyway as requested.");
    }

    boolean wasActive = isActive();
    try {
        doBind(localAddress);
    } catch (Throwable t) {
        safeSetFailure(promise, t);
        closeIfClosed();
        return;
    }

    if (!wasActive && isActive()) {
        invokeLater(new Runnable() {
            @Override
            public void run() {
                //这里看到会从pipeline中依次执行channelActive事件
                pipeline.fireChannelActive();
            }
        });
    }

    safeSetSuccess(promise);
}

/**
 * NioServerSocketChannel:
 * 第1968行代码处：
 */
@SuppressJava6Requirement(reason = "Usage guarded by java version check")
@Override
protected void doBind(SocketAddress localAddress) throws Exception {
    /*
    这里会根据Java不同的版本来执行不同的绑定代码。而看到“javaChannel()”就知道这里会走到NIO编程中的代码里了，
    也就是NIO编程中的绑定端口的代码
     */
    if (PlatformDependent.javaVersion() >= 7) {
        javaChannel().bind(localAddress, config.getBacklog());
    } else {
        javaChannel().socket().bind(localAddress, config.getBacklog());
    }
}

/**
 * AbstractChannel:
 * 第1976行代码处：
 * 该方法就是把任务放到taskQueue中
 */
private void invokeLater(Runnable task) {
    try {
        eventLoop().execute(task);
    } catch (RejectedExecutionException e) {
        logger.warn("Can't invoke task later as EventLoop rejected it", e);
    }
}

/**
 * DefaultChannelPipeline:
 * 第1980行代码处：
 */
@Override
public final ChannelPipeline fireChannelActive() {
    //这里和channelRegistered事件的执行过程是类似的，从pipeline中head到tail执行所有的inboundHandler
    AbstractChannelHandlerContext.invokeChannelActive(head);
    return this;
}

/**
 * AbstractChannelHandlerContext:
 */
static void invokeChannelActive(final AbstractChannelHandlerContext next) {
    EventExecutor executor = next.executor();
    //同之前的分析，该方法会返回true
    if (executor.inEventLoop()) {
        next.invokeChannelActive();
    } else {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                next.invokeChannelActive();
            }
        });
    }
}

/**
 * 第2037行代码处：
 */
private void invokeChannelActive() {
    if (invokeHandler()) {
        try {
            //这里也就是在执行每一个inboundHandler的active事件（以下以HeadContext为例来看一下执行过程）
            ((ChannelInboundHandler) handler()).channelActive(this);
        } catch (Throwable t) {
            invokeExceptionCaught(t);
        }
    } else {
        fireChannelActive();
    }
}

/**
 * DefaultChannelPipeline:
 * 第2055行代码处：
 * 因为传进来的是head，所以这里调用的是HeadContext的channelActive方法
 */
@Override
public void channelActive(ChannelHandlerContext ctx) {
    /*
    这里是调用下一个inboundHandler的channelActive方法。如果是TailContext的话，就会去执行
    它的channelActive方法。但是TailContext的channelActive方法是一个空实现，所以这里
    就不再具体展开分析了，调用的流程都是和HeadContext类似的
     */
    ctx.fireChannelActive();

    readIfIsAutoRead();
}

/**
 * AbstractChannelHandlerContext:
 * 第2076行代码处：
 */
@Override
public ChannelHandlerContext fireChannelActive() {
    /*
    因为这里是调用channelActive事件，站在服务端的角度来说相当于入站事件
    所以当通过findContextInbound方法拿到下一个inboundHandler时候，就调用
    它的channelActive方法
     */
    invokeChannelActive(findContextInbound(MASK_CHANNEL_ACTIVE));
    return this;
}

/**
 * AbstractNioChannel:
 * 第2078行代码处：
 * readIfIsAutoRead方法中又会从pipeline中从tail到head遍历执行所有outboundHandler的读事件，
 * 之前已经分析过很多这样的流程了，这里就不再赘述了。所以下面就来看一下其中的关键代码：doBeginRead
 */
@Override
protected void doBeginRead() throws Exception {
    final SelectionKey selectionKey = this.selectionKey;
    if (!selectionKey.isValid()) {
        return;
    }

    readPending = true;

    final int interestOps = selectionKey.interestOps();
    if ((interestOps & readInterestOp) == 0) {
        /*
        这里可以看到跟NIO编程中一样，重新注册对OP_ACCEPT（服务端）或OP_READ（客户端）事件感兴趣
        （详见之前的第162行和第220行代码处）
         */
        selectionKey.interestOps(interestOps | readInterestOp);
    }
}

/**
 * Bootstrap:
 * 第59行代码处：
 * 分析完服务端的doBind方法后，现在来分析一下客户端的doResolveAndConnect方法
 */
private ChannelFuture doResolveAndConnect(final SocketAddress remoteAddress, final SocketAddress localAddress) {
    //之前已经分析了initAndRegister方法的具体执行过程
    final ChannelFuture regFuture = initAndRegister();
    final Channel channel = regFuture.channel();

    if (regFuture.isDone()) {
        if (!regFuture.isSuccess()) {
            return regFuture;
        }
        return doResolveAndConnect0(channel, remoteAddress, localAddress, channel.newPromise());
    } else {
        final PendingRegistrationPromise promise = new PendingRegistrationPromise(channel);
        regFuture.addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                Throwable cause = future.cause();
                if (cause != null) {
                    promise.setFailure(cause);
                } else {
                    promise.registered();
                    doResolveAndConnect0(channel, remoteAddress, localAddress, promise);
                }
            }
        });
        return promise;
    }
}

private ChannelFuture doResolveAndConnect0(final Channel channel, SocketAddress remoteAddress,
                                           final SocketAddress localAddress, final ChannelPromise promise) {
    try {
        final EventLoop eventLoop = channel.eventLoop();
        AddressResolver resolver;
        try {
            resolver = this.resolver.getResolver(eventLoop);
        } catch (Throwable cause) {
            channel.close();
            return promise.setFailure(cause);
        }

        if (!resolver.isSupported(remoteAddress) || resolver.isResolved(remoteAddress)) {
            doConnect(remoteAddress, localAddress, promise);
            return promise;
        }

        final Future resolveFuture = resolver.resolve(remoteAddress);

        if (resolveFuture.isDone()) {
            final Throwable resolveFailureCause = resolveFuture.cause();

            if (resolveFailureCause != null) {
                channel.close();
                promise.setFailure(resolveFailureCause);
            } else {
                doConnect(resolveFuture.getNow(), localAddress, promise);
            }
            return promise;
        }

        resolveFuture.addListener(new FutureListener() {
            @Override
            public void operationComplete(Future future) throws Exception {
                if (future.cause() != null) {
                    channel.close();
                    promise.setFailure(future.cause());
                } else {
                    doConnect(future.getNow(), localAddress, promise);
                }
            }
        });
    } catch (Throwable cause) {
        promise.tryFailure(cause);
    }
    return promise;
}

/**
 * 第2180行代码处：
 */
private static void doConnect(
        final SocketAddress remoteAddress, final SocketAddress localAddress, final ChannelPromise connectPromise) {

    final Channel channel = connectPromise.channel();
    //同上，新创建了一个任务放到了taskQueue中
    channel.eventLoop().execute(new Runnable() {
        @Override
        public void run() {
            if (localAddress == null) {
                channel.connect(remoteAddress, connectPromise);
            } else {
                channel.connect(remoteAddress, localAddress, connectPromise);
            }
            connectPromise.addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
        }
    });
}

/**
 * AbstractChannel:
 * 第2214行代码处：
 */
@Override
public ChannelFuture connect(SocketAddress remoteAddress, ChannelPromise promise) {
    return pipeline.connect(remoteAddress, promise);
}

/**
 * DefaultChannelPipeline:
 */
@Override
public final ChannelFuture connect(SocketAddress remoteAddress, ChannelPromise promise) {
    /*
    不出意外的话，又是从pipeline中从tail到head遍历执行所有outboundHandler的connect事件
    （注：既然有这么多pipeline中inbound、outbound的遍历执行的地方，为什么不抽象成两个公有的实现？
    通过传入不同的事件来实现不同的功能？）
     */
    return tail.connect(remoteAddress, promise);
}

/**
 * AbstractChannelHandlerContext:
 */
@Override
public ChannelFuture connect(SocketAddress remoteAddress, ChannelPromise promise) {
    return connect(remoteAddress, null, promise);
}

@Override
public ChannelFuture connect(
        final SocketAddress remoteAddress, final SocketAddress localAddress, final ChannelPromise promise) {
    ObjectUtil.checkNotNull(remoteAddress, "remoteAddress");

    if (isNotValidPromise(promise, false)) {
        return promise;
    }

    //这里就是在找下一个执行连接动作的outboundHandler
    final AbstractChannelHandlerContext next = findContextOutbound(MASK_CONNECT);
    EventExecutor executor = next.executor();
    if (executor.inEventLoop()) {
        next.invokeConnect(remoteAddress, localAddress, promise);
    } else {
        safeExecute(executor, new Runnable() {
            @Override
            public void run() {
                next.invokeConnect(remoteAddress, localAddress, promise);
            }
        }, promise, null, false);
    }
    return promise;
}

/**
 * 第2266行代码处：
 */
private void invokeConnect(SocketAddress remoteAddress, SocketAddress localAddress, ChannelPromise promise) {
    if (invokeHandler()) {
        try {
            //这里也就是在执行每一个outboundHandler的connect事件（以下以HeadContext为例来看一下执行过程）
            ((ChannelOutboundHandler) handler()).connect(this, remoteAddress, localAddress, promise);
        } catch (Throwable t) {
            notifyOutboundHandlerException(t, promise);
        }
    } else {
        connect(remoteAddress, localAddress, promise);
    }
}

/**
 * DefaultChannelPipeline:
 * 第2285行代码处：
 */
@Override
public void connect(
        ChannelHandlerContext ctx,
        SocketAddress remoteAddress, SocketAddress localAddress,
        ChannelPromise promise) {
    unsafe.connect(remoteAddress, localAddress, promise);
}

/**
 * AbstractChannel:
 */
@Override
public final void connect(
        final SocketAddress remoteAddress, final SocketAddress localAddress, final ChannelPromise promise) {
    if (!promise.setUncancellable() || !ensureOpen(promise)) {
        return;
    }

    try {
        if (connectPromise != null) {
            throw new ConnectionPendingException();
        }

        boolean wasActive = isActive();
        if (doConnect(remoteAddress, localAddress)) {
            fulfillConnectPromise(promise, wasActive);
        } else {
            connectPromise = promise;
            requestedRemoteAddress = remoteAddress;

            int connectTimeoutMillis = config().getConnectTimeoutMillis();
            if (connectTimeoutMillis > 0) {
                //这里schedule方法会创建一个定时任务，之前遇到的都是execute方法，所以这里来具体看一下其是怎么实现的
                connectTimeoutFuture = eventLoop().schedule(new Runnable() {
                    @Override
                    public void run() {
                        ChannelPromise connectPromise = AbstractNioChannel.this.connectPromise;
                        ConnectTimeoutException cause =
                                new ConnectTimeoutException("connection timed out: " + remoteAddress);
                        if (connectPromise != null && connectPromise.tryFailure(cause)) {
                            close(voidPromise());
                        }
                    }
                }, connectTimeoutMillis, TimeUnit.MILLISECONDS);
            }

            promise.addListener(new ChannelFutureListener() {
                @Override
                public void operationComplete(ChannelFuture future) throws Exception {
                    if (future.isCancelled()) {
                        if (connectTimeoutFuture != null) {
                            connectTimeoutFuture.cancel(false);
                        }
                        connectPromise = null;
                        close(voidPromise());
                    }
                }
            });
        }
    } catch (Throwable t) {
        promise.tryFailure(annotateConnectException(t, remoteAddress));
        closeIfClosed();
    }
}

/**
 * NioSocketChannel:
 * 第2322行代码处：
 */
@Override
protected boolean doConnect(SocketAddress remoteAddress, SocketAddress localAddress) throws Exception {
    if (localAddress != null) {
        doBind0(localAddress);
    }

    boolean success = false;
    try {
        boolean connected = SocketUtils.connect(javaChannel(), remoteAddress);
        if (!connected) {
            //同NIO编程中一样，为该通道注册OP_CONNECT事件
            selectionKey().interestOps(SelectionKey.OP_CONNECT);
        }
        success = true;
        return connected;
    } finally {
        if (!success) {
            doClose();
        }
    }
}

/**
 * SocketUtils:
 * 第2375行代码处：
 */
public static boolean connect(final SocketChannel socketChannel, final SocketAddress remoteAddress)
        throws IOException {
    try {
        return AccessController.doPrivileged(new PrivilegedExceptionAction() {
            @Override
            public Boolean run() throws IOException {
                //这里也就是在NIO编程中，客户端连接服务端的代码
                return socketChannel.connect(remoteAddress);
            }
        });
    } catch (PrivilegedActionException e) {
        throw (IOException) e.getCause();
    }
}

/**
 * AbstractScheduledEventExecutor:
 * 第2331行代码处：
 */
@Override
public ScheduledFuture schedule(Runnable command, long delay, TimeUnit unit) {
    ObjectUtil.checkNotNull(command, "command");
    ObjectUtil.checkNotNull(unit, "unit");
    //delay非负处理
    if (delay < 0) {
        delay = 0;
    }
    validateScheduled0(delay, unit);

    return schedule(new ScheduledFutureTask(
            this,
            command,
            deadlineNanos(unit.toNanos(delay))));
}

private  ScheduledFuture schedule(final ScheduledFutureTask task) {
    //同之前的分析，该方法会返回true
    if (inEventLoop()) {
        scheduleFromEventLoop(task);
    } else {
        final long deadlineNanos = task.deadlineNanos();
        if (beforeScheduledTaskSubmitted(deadlineNanos)) {
            execute(task);
        } else {
            lazyExecute(task);
            if (afterScheduledTaskSubmitted(deadlineNanos)) {
                execute(WAKEUP_TASK);
            }
        }
    }

    return task;
}

/**
 * 第2431行代码处：
 */
final void scheduleFromEventLoop(final ScheduledFutureTask task) {
    //这里实际上就是将任务放在了定时任务队列中，后续再去等线程执行runAllTasks方法，把任务拿出来再执行
    scheduledTaskQueue().add(task.setId(++nextTaskId));
}

PriorityQueue> scheduledTaskQueue() {
    if (scheduledTaskQueue == null) {
        scheduledTaskQueue = new DefaultPriorityQueue>(
                SCHEDULED_FUTURE_TASK_COMPARATOR,
                11);
    }
    return scheduledTaskQueue;
}

@SuppressWarnings("unchecked")
public DefaultPriorityQueue(Comparator comparator, int initialSize) {
    this.comparator = ObjectUtil.checkNotNull(comparator, "comparator");
    //这里可以看到创建了一个Netty自己定义的优先级队列（继承了java.util.AbstractQueue）
    queue = (T[]) (initialSize != 0 ? new PriorityQueueNode[initialSize] : EMPTY_ARRAY);
} 
  
在执行完上述的所有过程后，运行NioEventLoop类run方法的线程，在没有遇到事件来临的时候，会阻塞在select方法处，直到有事件来临（这和NIO编程中的执行逻辑是一样的）。
 
  
 
  
4 sync方法
 
  
/**
 * DefaultChannelPromise:
 */
@Override
public ChannelPromise sync() throws InterruptedException {
    super.sync();
    return this;
}

/**
 * DefaultPromise:
 */
@Override
public Promise sync() throws InterruptedException {
    await();
    rethrowIfFailed();
    return this;
}

/**
 * DefaultChannelPromise:
 * 第15行代码处：
 */
@Override
public ChannelPromise await() throws InterruptedException {
    super.await();
    return this;
}

/**
 * DefaultPromise:
 */
@Override
public Promise await() throws InterruptedException {
    if (isDone()) {
        return this;
    }

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

    checkDeadLock();

    synchronized (this) {
        while (!isDone()) {
            incWaiters();
            try {
                /*
                这里就是会让当前线程阻塞住，直到上一个异步操作执行完毕后再被唤醒，也就是“异步转同步”
                比如“bind(9000).sync()”这行代码就是在等待初始化注册和绑定端口工作都做完了以后，当前线程再被唤醒；
                而“closeFuture().sync()”这行代码就是在等待通道关闭、处理完毕后，当前线程再被唤醒
                 */
                wait();
            } finally {
                decWaiters();
            }
        }
    }
    return this;
}
 
  
 
  
5 writeAndFlush方法
 
  
/**
 * AbstractChannel:
 * 这里以服务端向客户端发送数据来举例
 */
@Override
public ChannelFuture writeAndFlush(Object msg) {
    /*
    需要注意的是：这里拿到的pipeline就是在服务端有我们自定义handler的pipeline，
    也就是NioServerSocketChannel的pipeline
     */
    return pipeline.writeAndFlush(msg);
}

/**
 * DefaultChannelPipeline:
 */
@Override
public final ChannelFuture writeAndFlush(Object msg) {
    //因为是出站事件，所以从tail开始遍历所有的outboundHandler
    return tail.writeAndFlush(msg);
}

/**
 * AbstractChannelHandlerContext:
 */
@Override
public ChannelFuture writeAndFlush(Object msg) {
    return writeAndFlush(msg, newPromise());
}

@Override
public ChannelFuture writeAndFlush(Object msg, ChannelPromise promise) {
    write(msg, true, promise);
    return promise;
}

private void write(Object msg, boolean flush, ChannelPromise promise) {
    ObjectUtil.checkNotNull(msg, "msg");
    try {
        if (isNotValidPromise(promise, true)) {
            ReferenceCountUtil.release(msg);
            return;
        }
    } catch (RuntimeException e) {
        ReferenceCountUtil.release(msg);
        throw e;
    }

    //这里就是在找下一个执行写动作的outboundHandler
    final AbstractChannelHandlerContext next = findContextOutbound(flush ?
            (MASK_WRITE | MASK_FLUSH) : MASK_WRITE);
    final Object m = pipeline.touch(msg, next);
    EventExecutor executor = next.executor();
    if (executor.inEventLoop()) {
        if (flush) {
            //传进来的flush为true，所以走下面的方法
            next.invokeWriteAndFlush(m, promise);
        } else {
            next.invokeWrite(m, promise);
        }
    } else {
        final WriteTask task = WriteTask.newInstance(next, m, promise, flush);
        if (!safeExecute(executor, task, promise, m, !flush)) {
            task.cancel();
        }
    }
}

void invokeWriteAndFlush(Object msg, ChannelPromise promise) {
    if (invokeHandler()) {
        //这里就可以看到writeAndFlush方法是通过write和flush两个事件来执行的
        invokeWrite0(msg, promise);
        invokeFlush0();
    } else {
        writeAndFlush(msg, promise);
    }
}

/**
 * 第72行代码处：
 */
private void invokeWrite0(Object msg, ChannelPromise promise) {
    try {
        /*
        这里拿到的handler是编码的handler，即StringEncoder、ObjectEncoder等等，
        执行它写好的write方法就行了
         */
        ((ChannelOutboundHandler) handler()).write(this, msg, promise);
    } catch (Throwable t) {
        notifyOutboundHandlerException(t, promise);
    }
}

/**
 * 第73行代码处：
 */
private void invokeFlush0() {
    try {
        /*
        这里的handler跟上面invokeWrite0方法的handler是同一个，也就是那个编码的handler，
        执行它写好的flush方法即可（里面同时还会调用HeadContext的flush方法）
         */
        ((ChannelOutboundHandler) handler()).flush(this);
    } catch (Throwable t) {
        invokeExceptionCaught(t);
    }
}
 
  
 
  
6 心跳检测机制
 
  
所谓心跳，即在TCP长连接中，客户端和服务器之间定期发送的一种特殊的数据包，通知对方自己还在线，以确保TCP连接的有效性。在Netty中，实现心跳机制的关键是IdleStateHandler（我之前写过一个Netty心跳检测的示例程序，感兴趣的可以查看《Netty实现心跳检测机制》）。
 
  
使用IdleStateHandler的方式也是十分简单，只需要在pipeline中添加就行了（还需要在后面的handler中加上超时的处理）：
 
  
pipeline.addLast(new IdleStateHandler(3, 0, 0));
 
  
这里演示的是IdleStateHandler的readerIdleTime参数指定超过3秒还没收到客户端的连接，会触发IdleStateEvent事件并且交给下一个handler处理。所以下一个handler必须实现userEventTriggered方法处理对应的事件。
 
  
6.1 构造器
 
  
/**
 * IdleStateHandler:
 * <1>readerIdleTimeSeconds：读超时。即当在指定的时间间隔内没有从Channel中读取到数据时，会触发一个READER_IDLE的
 * IdleStateEvent事件；
 *
 * <2>writerIdleTimeSeconds：写超时。即当在指定的时间间隔内没有数据写入到Channel时，会触发一个WRITER_IDLE的
 * IdleStateEvent事件；
 *
 * <3>allIdleTimeSeconds：读写超时。即当在指定的时间间隔内没有读或写操作时，会触发一个ALL_IDLE的IdleStateEvent事件
 */
public IdleStateHandler(
        int readerIdleTimeSeconds,
        int writerIdleTimeSeconds,
        int allIdleTimeSeconds) {

    this(readerIdleTimeSeconds, writerIdleTimeSeconds, allIdleTimeSeconds,
            TimeUnit.SECONDS);
}

public IdleStateHandler(
        long readerIdleTime, long writerIdleTime, long allIdleTime,
        TimeUnit unit) {
    this(false, readerIdleTime, writerIdleTime, allIdleTime, unit);
}

public IdleStateHandler(boolean observeOutput,
                        long readerIdleTime, long writerIdleTime, long allIdleTime,
                        TimeUnit unit) {
    ObjectUtil.checkNotNull(unit, "unit");

    /*
    该参数用来表示是否考虑出站特别慢的情况（可能是网络传输比较慢，也可能是客户端处理比较慢）。比如出站用了10秒，
    而空闲时间是5秒，那么在数据还有没有处理完的时候，就已经触发了空闲超时事件。这明显是不合理的。但这里传进来的
    observeOutput是false，也就是不考虑这种情况（如果需要考虑这种情况的话，调用带observeOutput参数的构造器
    就行了）
     */
    this.observeOutput = observeOutput;

    //设置readerIdleTime、writerIdleTimeNanos和allIdleTimeNanos
    if (readerIdleTime <= 0) {
        readerIdleTimeNanos = 0;
    } else {
        readerIdleTimeNanos = Math.max(unit.toNanos(readerIdleTime), MIN_TIMEOUT_NANOS);
    }
    if (writerIdleTime <= 0) {
        writerIdleTimeNanos = 0;
    } else {
        writerIdleTimeNanos = Math.max(unit.toNanos(writerIdleTime), MIN_TIMEOUT_NANOS);
    }
    if (allIdleTime <= 0) {
        allIdleTimeNanos = 0;
    } else {
        allIdleTimeNanos = Math.max(unit.toNanos(allIdleTime), MIN_TIMEOUT_NANOS);
    }
}
 
  
6.2 channelActive方法
 
  
/**
 * IdleStateHandler:
 */
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
    //该方法会把定时任务放到eventLoop的任务队列中等待去执行
    initialize(ctx);
    //该处会调用下一个handler的channelActive方法
    super.channelActive(ctx);
}

/**
 * 第7行代码处：
 */
private void initialize(ChannelHandlerContext ctx) {
    switch (state) {
        case 1:
        case 2:
            return;
    }

    /*
    state置为1表示已经初始化过了，同一次channelRead别处调用再进来就会在上面的代码中return了
    （为2表示已经被销毁了，也直接退出）
     */
    state = 1;
    //如果observeOutput设置为true的话，需要记录一些出站缓冲区的相关信息，以考虑出站特别慢的情况
    initOutputChanged(ctx);

    //重置lastReadTime和lastWriteTime为当前时间
    lastReadTime = lastWriteTime = ticksInNanos();
    //如果readerIdleTimeNanos>0，就会把定时任务加到scheduledTaskQueue中
    if (readerIdleTimeNanos > 0) {
        readerIdleTimeout = schedule(ctx, new ReaderIdleTimeoutTask(ctx),
                readerIdleTimeNanos, TimeUnit.NANOSECONDS);
    }
    //如果writerIdleTimeNanos>0，就会把定时任务加到scheduledTaskQueue中
    if (writerIdleTimeNanos > 0) {
        writerIdleTimeout = schedule(ctx, new WriterIdleTimeoutTask(ctx),
                writerIdleTimeNanos, TimeUnit.NANOSECONDS);
    }
    //如果allIdleTimeNanos>0，就会把定时任务加到scheduledTaskQueue中
    if (allIdleTimeNanos > 0) {
        allIdleTimeout = schedule(ctx, new AllIdleTimeoutTask(ctx),
                allIdleTimeNanos, TimeUnit.NANOSECONDS);
    }
}

/**
 * 第28行代码处：
 */
private void initOutputChanged(ChannelHandlerContext ctx) {
    if (observeOutput) {
        Channel channel = ctx.channel();
        Channel.Unsafe unsafe = channel.unsafe();
        ChannelOutboundBuffer buf = unsafe.outboundBuffer();

        /*
        这里会记录一些出站缓冲区的相关信息（缓冲对象的hashCode、buf剩余待写的字节数和当前信息的刷新进度），
        为了后面的hasOutputChanged方法做判断用
         */
        if (buf != null) {
            lastMessageHashCode = System.identityHashCode(buf.current());
            lastPendingWriteBytes = buf.totalPendingWriteBytes();
            lastFlushProgress = buf.currentProgress();
        }
    }
}

/**
 * 第34行、第39行、第44行、第102行、第124行、第140行、第163行、第184行和第208行代码处：
 */
ScheduledFuture schedule(ChannelHandlerContext ctx, Runnable task, long delay, TimeUnit unit) {
    /*
    可以看到这里也是调用了schedule方法。之前已经分析过了，该方法会把任务放进scheduledTaskQueue中，
    后续再去等线程执行runAllTasks方法，把任务拿出来再执行
     */
    return ctx.executor().schedule(task, delay, unit);
}

/**
 * 第34行代码处：
 * ReaderIdleTimeoutTask的run方法，定时任务最终会走到这里
 */
@Override
protected void run(ChannelHandlerContext ctx) {
    long nextDelay = readerIdleTimeNanos;
    if (!reading) {
        /*
        ticksInNanos方法是用来获取当前时间，减去上次channelRead的时间表示的就是距离上次channelRead
        后已经过了多久了。这时候用设置好的read超时时间再去减的话，结果就是下次的超时时间（注意：这一步是发生在
        reading为false，也就是channelRead方法执行完毕的时候）
         */
        nextDelay -= ticksInNanos() - lastReadTime;
    }

    if (nextDelay <= 0) {
        /*
        如上面所说，如果nextDelay<=0就说明已经到达或超过了超时时间。此时再次添加心跳任务进行下一次的心跳检测
        从这里可以看出，Netty的心跳定时任务是通过循环调用schedule方法来添加任务，然后判断当前时间差来实现的
         */
        readerIdleTimeout = schedule(ctx, this, readerIdleTimeNanos, TimeUnit.NANOSECONDS);

        boolean first = firstReaderIdleEvent;
        //firstReaderIdleEvent重新置为false
        firstReaderIdleEvent = false;

        try {
            //构建一个READER_IDLE事件交给下面的userEventTriggered方法
            IdleStateEvent event = newIdleStateEvent(IdleState.READER_IDLE, first);
            /*
            执行下一个handler的userEventTriggered方法（也就是我们必须要实现的方法）来处理超时
            （该方法中就一行代码：ctx.fireUserEventTriggered(evt);）    
             */
            channelIdle(ctx, event);
        } catch (Throwable t) {
            ctx.fireExceptionCaught(t);
        }
    } else {
        /*
        如上面所说，如果nextDelay>0就说明此时还没有超时，那么就会把新的定时任务加到scheduledTaskQueue中
        此时nextDelay为更新过的超时时间
         */
        readerIdleTimeout = schedule(ctx, this, nextDelay, TimeUnit.NANOSECONDS);
    }
}

/**
 * 第39行代码处：
 * WriterIdleTimeoutTask的run方法，定时任务最终会走到这里
 */
@Override
protected void run(ChannelHandlerContext ctx) {

    long lastWriteTime = this.lastWriteTime;
    //和ReaderIdleTimeoutTask的run方法一样，更新一下此时的nextDelay
    long nextDelay = writerIdleTimeNanos - (ticksInNanos() - lastWriteTime);
    if (nextDelay <= 0) {
        //如果nextDelay<=0就说明已经到达或超过了超时时间。此时再次添加心跳任务进行下一次的心跳检测
        writerIdleTimeout = schedule(ctx, this, writerIdleTimeNanos, TimeUnit.NANOSECONDS);

        boolean first = firstWriterIdleEvent;
        //firstWriterIdleEvent重新置为false
        firstWriterIdleEvent = false;

        try {
            //考虑出站特别慢的情况
            if (hasOutputChanged(ctx, first)) {
                return;
            }
            //构建一个WRITER_IDLE事件交给下面的userEventTriggered方法
            IdleStateEvent event = newIdleStateEvent(IdleState.WRITER_IDLE, first);
            //执行下一个handler的userEventTriggered方法（也就是我们必须要实现的方法）来处理超时
            channelIdle(ctx, event);
        } catch (Throwable t) {
            ctx.fireExceptionCaught(t);
        }
    } else {
        /*
        如果nextDelay>0就说明此时还没有超时，那么就会把新的定时任务加到scheduledTaskQueue中
        此时nextDelay为更新过的超时时间
         */
        writerIdleTimeout = schedule(ctx, this, nextDelay, TimeUnit.NANOSECONDS);
    }
}

/**
 * 第44行代码处：
 * AllIdleTimeoutTask的run方法，定时任务最终会走到这里
 */
@Override
protected void run(ChannelHandlerContext ctx) {

    long nextDelay = allIdleTimeNanos;
    if (!reading) {
        /*
        同理，更新一下此时的nextDelay（注意：这一步是发生在reading为false，也就是channelRead方法
        执行完毕的时候）
         */
        nextDelay -= ticksInNanos() - Math.max(lastReadTime, lastWriteTime);
    }
    if (nextDelay <= 0) {
        //如果nextDelay<=0就说明已经到达或超过了超时时间。此时再次添加心跳任务进行下一次的心跳检测
        allIdleTimeout = schedule(ctx, this, allIdleTimeNanos, TimeUnit.NANOSECONDS);

        boolean first = firstAllIdleEvent;
        //firstAllIdleEvent重新置为false
        firstAllIdleEvent = false;

        try {
            //考虑出站特别慢的情况
            if (hasOutputChanged(ctx, first)) {
                return;
            }

            //构建一个ALL_IDLE事件交给下面的userEventTriggered方法
            IdleStateEvent event = newIdleStateEvent(IdleState.ALL_IDLE, first);
            //执行下一个handler的userEventTriggered方法（也就是我们必须要实现的方法）来处理超时
            channelIdle(ctx, event);
        } catch (Throwable t) {
            ctx.fireExceptionCaught(t);
        }
    } else {
        /*
        如果nextDelay>0就说明此时还没有超时，那么就会把新的定时任务加到scheduledTaskQueue中
        此时nextDelay为更新过的超时时间
         */
        allIdleTimeout = schedule(ctx, this, nextDelay, TimeUnit.NANOSECONDS);
    }
}

/**
 * 第148行和第192行代码处：
 */
private boolean hasOutputChanged(ChannelHandlerContext ctx, boolean first) {
    //如果observeOutput为false，也就是不考虑出站特别慢，就直接返回false
    if (observeOutput) {

        /*
        如果最后记录的时间和上一次记录的不同，说明此时是第一次进入该方法，或者可能是写操作已经完成了，
        更新了lastWriteTime。此时重新更新一下lastChangeCheckTimeStamp
         */
        if (lastChangeCheckTimeStamp != lastWriteTime) {
            lastChangeCheckTimeStamp = lastWriteTime;

            /*
            如果在出站处理完成之前又触发了下一次的定时任务，从而走到这里的话，first就是false
            也就是说在定时任务两次调用hasOutputChanged方法的过程中，出站事件一直在处理中、没有执行
            完毕。那么此时就直接返回true，后面也不会再处理userEventTriggered方法，直到出站结束
             */
            if (!first) {
                return true;
            }
        }

        Channel channel = ctx.channel();
        Unsafe unsafe = channel.unsafe();
        ChannelOutboundBuffer buf = unsafe.outboundBuffer();

        if (buf != null) {
            //如果出站缓冲区有数据的话，说明之前在initOutputChanged方法中记录了这些信息，此时再次获取这些信息进行比对
            int messageHashCode = System.identityHashCode(buf.current());
            long pendingWriteBytes = buf.totalPendingWriteBytes();

            //如果不等，说明缓冲区的数据在慢慢发生变化，也就是出站特别慢的情况。此时重新更新一下这些值
            if (messageHashCode != lastMessageHashCode || pendingWriteBytes != lastPendingWriteBytes) {
                lastMessageHashCode = messageHashCode;
                lastPendingWriteBytes = pendingWriteBytes;

                /*
                走到这里还是要判断一下first的值，如果为false（不是第一次调用），就不会触发下一个handler的
                userEventTriggered方法；如果为true（第一次调用），就会触发。按照原先设想的逻辑：如果发现
                出站特别慢，那么此时就不应该去触发userEventTriggered方法，静静等待出站完毕就好了。那么为什么
                第一次调用的时候需要触发呢？其实这里是Netty设计者的考虑。如果真的是发生了出站特别慢的情况，
                很可能会引发后续的OOM。所以这里第一次调用会触发userEventTriggered方法，从而给使用者一个警告
                如果这里不触发，从而最终可能发生OOM的话，可能会花费很大的功夫才能找到原来是出站特别慢（可能是
                网络传输比较慢，也可能是客户端处理比较慢）才导致的OOM
                 */
                if (!first) {
                    return true;
                }
            }

            /*
            lastFlushProgress属性是4.1.x版本中新加的，之前4.0.x版本中没有这个属性。添加的原因详见
            https://github.com/netty/netty/commit/51112e2b36ec5550a73d72bfc59f4523f7b8ec27
             */
            long flushProgress = buf.currentProgress();
            if (flushProgress != lastFlushProgress) {
                lastFlushProgress = flushProgress;

                //同上面的解释
                if (!first) {
                    return true;
                }
            }
        }
    }

    return false;
}
 
  
6.3 channelRead方法
 
  
/**
 * IdleStateHandler:
 */
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
    if (readerIdleTimeNanos > 0 || allIdleTimeNanos > 0) {
        /*
        reading为true表示channelRead方法还在执行中，在channelReadComplete方法中会重置为false，
        也就是channelRead方法执行完毕了
         */
        reading = true;
        //每一次channelRead进来的时候都会将firstReaderIdleEvent和firstAllIdleEvent置为true
        firstReaderIdleEvent = firstAllIdleEvent = true;
    }
    /*
    该处会调用下一个handler的channelRead方法，也就是IdleStateHandler的channelRead方法并没有做什么
    实际的事情，只是更改了一些标志位而已
     */
    ctx.fireChannelRead(msg);
}

 
  
 
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Netty)

        

            

                
    
                    
  • netty-简易聊天
                        2401_84046645
程序员java开发语言
                        
    publicvoidsend(Stringtext){channel.writeAndFlush(Unpooled.copiedBuffer(text.getBytes()));}publicvoidcloseConnect(){send(“bye”);channel.close();}}classMyHandlerextendsChannelInboundHandlerAdapter{@Over
    
                    
    • 
                    
  • Netty权威指南：Netty总结-高性能与可靠性
                        Ty_1106
Nettyjava网络rpc
                        
    第二十二章高性能之道22.1RPC调用性能模型分析22.1.1传统RPC调用性能差三宗罪：网络传输采用同步阻塞I/O导致经常性阻塞序列化性能差线程模型问题22.1.2I/O通信性能三要素传输：BIO、NIO或者AIO协议：HTTP公有协议，内部私有协议线程：数据报如何读取，Reactor线程模型22.2Netty高性能之道22.2.1异步非阻塞通信I/O多路复用技术22.2.2高效的Reactor
    
                    
    • 
                    
  • netty4源码阅读与分析---netty线程模型
                        红尘之一骑
javaNIOnetty源码阅读与分析
                        
    本文主要说下我自己对netty线程模型的理解，以及这样的线程模型的好处。通俗的来讲，netty的线程模型描述的就是老板和员工的故事。老板(通常情况下是一个老板)负责接活，与客户沟通，协调(netty的accept),谈成后(通道建立)，他需要从员工中选出一位员工来负责处理后续具体的事宜(worker线程，这里我们有16位员工，编号1-16)，员工做事时按照任务的先后顺序进行处理，这样可以避免错乱，
    
                    
    • 
                    
  • 深度长文解析SpringWebFlux响应式框架15个核心组件源码
                        快乐非自愿
javaspring
                        
    SpringWebFlux介绍SpringWebFlux是SpringFramework5.0版本引入的一个响应式Web框架，它与SpringMVC并存，提供了一种全新的编程范式，支持异步非阻塞的Web应用开发。WebFlux完全基于响应式编程模型，支持ReactiveStreams规范，可以在诸如Netty、Undertow以及Servlet3.1+容器上运行。WebFlux的核心控制器是Dis
    
                    
    • 
                    
  • Java网络编程：IO，NIO与Netty
                        坚持是一种态度
javajava网络编程NettyJavaIONIONIO与Netty
                        
    Java网络编程：IO，NIO与NettyJava网络编程：IO，NIO与NettyJavaI/O相关概念同步与异步阻塞与非阻塞OIONIOAIOreactor模型proactor模型JavaIO应用场景Netty简介NIO与Netty生产使用Java网络编程：IO，NIO与Netty新公司新项目，项目需要在硬件和软件平台进行信息传递，具体来说使用Netty。硬件和软件使用socket连接，硬件作
    
                    
    • 
                    
  • java reactor模式例子_Netty Reactor模式实现原理详解
                        weixin_39923623
javareactor模式例子
                        
    在前面的文章中(Reactor模型详解)，我们讲解了Reactor模式的各种演变形式，本文主要讲解的则是Netty是如何实现Reactor模式的。这里关于Netty实现的Reactor模式，需要说明的是，其实现的模式如下图所示：对于Netty使用的Reactor模式，其主要特点如下：使用一个线程作为mainReactor，专门用于监听客户端的连接事件，当获取到事件之后就将该事件交由Acceptor
    
                    
    • 
                    
  • Netty实战二-实现UDP的单播和广播(1)
                        2401_84048671
程序员udp网络协议网络
                        
    publicclassAnswerHandlerextendsSimpleChannelInboundHandler{/应答的具体内容从常量字符串数组中取得，由nextQuote方法随机获取/privatestaticfinalString[]DICTIONARY={“一个男生暗恋一个女生很久了。一天自习课上，男生偷偷的传了小纸条给女生，上面写着“其实我注意你很久了”。不一会儿，女生传了另一张纸条
    
                    
    • 
                    
  • netty源码解读三（NioEventLoop）
                        orcharddd_real
nettyjavanetty
                        
    NioEventLoop初始化EventExecutor类型的数组数组大小默认为cpu数量的两倍，遍历数组，通过newNioEventLoop(xxx)往数组中添加元素，NioEventLoop继承了EventExecutor；每次需要线程时，执行chooser的next方法从数组中取出一个线程；关键代码打开netty源码，找到example包下的EchoService类，追溯创建boss线程组和
    
                    
    • 
                    
  • Netty源码分析:NioEventLoopGroup
                        HelloWorld_EE
netty源码分析源代码nettyEventLoop
                        
    Netty源码分析:NioEventLoopGroup在工作之余，看到自己公司的超哥（俞超）关于Netty的系列博文，讲解的很好，因此，自己在学习之余也跟了下源代码，来了解Netty，也做了相关的笔记，将形成系列博文，这是第一篇。超哥的博文地址在这里：http://www.jianshu.com/p/c5068caab217Netty版本：4.0.23.Final借用超哥的例子，一般服务端的代码如
    
                    
    • 
                    
  • netty-NioServerSocketChannel和boss NioEventLoopGroup 如何建立关系的
                        一个人的想法
javanetty
                        
    一、EventLoopGroupbossGroup=newNioEventLoopGroup();EventLoopGroupworkerGroup=newNioEventLoopGroup();1、boss或者workerNioEventLoopGroup初始化完成了一个NioEventLoop数组（默认机器核数的2倍）所有NioEventLoop持有了同一个Executor调用execute时
    
                    
    • 
                    
  • 经验笔记：RPC与高性能NIO框架
                        漆黑的莫莫
计算机网络笔记rpcnio
                        
    RPC与高性能NIO框架的经验笔记引言随着互联网技术的发展，分布式系统逐渐成为了现代软件架构的标准之一。在这种架构中，服务之间的通信变得尤为关键，而RPC（远程过程调用）作为一种服务间通信的方式，因其简便的使用方式和高效的性能表现而受到了广泛的关注。在实现RPC的过程中，选择合适的网络通信框架至关重要，尤其是那些基于NIO（非阻塞I/O）的高性能框架，如Netty。本文将首先介绍RPC的概念及其在
    
                    
    • 
                    
  • 基础学习之——Netty
                        北欧人写代码
学习网络服务器
                        
    Netty是一个基于Java的网络通信框架，提供了一种简单、高效、可扩展的方式来开发网络服务器和客户端应用程序。Netty的设计目标是提供一种统一的异步编程模型，使得开发者能够轻松地编写可维护和可重用的代码。Netty的核心组件包括：Channel：网络通信的通道，可以用于读取、写入和关闭操作。EventLoop：负责处理I/O事件，包括接收、发送和处理数据。ChannelHandler：用于处理
    
                    
    • 
                    
  • Springboot-websocket实现及底层原理
                        No.Ada
深入项目底层原理springbootwebsocket后端
                        
    引入依赖SpringBoot中的WebSocket依赖于SpringWebFlux模块，使用了ReactorNetty库来实现底层的WebSocket通信。org.springframework.bootspring-boot-starter-websocket服务端配置/***WebSocket配置类*/@ConfigurationpublicclassWebSocketConfig{/***注
    
                    
    • 
                    
  • 【Netty】实战：基于WebSocket的聊天室
                        马丁的代码日记
netty聊天室网络websockethttp
                        
    本文将使用Netty快速实现一个聊天室应用，该应用基于WebSocket协议，用户可以在浏览器内聊天。实现过程很简单，就几步。一、处理Http请求packagecn.md.netty.websocket.groupchat;importio.netty.channel.*;importio.netty.handler.codec.http.*;importio.netty.handler.ssl.
    
                    
    • 
                    
  • 精通 Spring Cloud Feign：从理论到实战的通信优化之路
                        TopicOnline
springcloud
                        
    一、服务间调用的几种方式使用SpringCloud开发微服务时，在服务消费者调用服务提供者时，底层通过HTTPClient的方式访问。但实际上在服务调用时，有主要以下来实现：使用JDK原生的URLConnection；Apache提供的HTTPClient；Netty提供的异步HTTPClient；Spring提供的RestTemplate。SpringCloud的SpringCloudOpenF
    
                    
    • 
                    
  • Dubbo与Netty
                        蹩脚的小三

                        
    CodecCodecSupportAbstractCodecTransportCodecCodecAdapterDispacherChannelHandlersDispatcherAllDispatcherAllChannelHandlerChannelEventRunnableWrappedChannelHandlerChannelHandlerChannelHandlerAdapterChan
    
                    
    • 
                    
  • netty开发模拟qq斗地主
                        平平无奇的Coding Peasant
nettyqq斗地主
                        
    为什么要搞这样一个项目满足自己的java网络多线程编程的欲望！因为之前一直都是搞web开发，服务器和客户端数据交流人家web服务器早就给你搞好了，比如tomcat,jetty...等等，其实之前脑子里就有想过--是否可以自己开发一个简单的类似tomcat的web服务器，这样做了的话，至少知道其实web开发是建立在网络多线程web服务器之上否则web开发无从谈起！市面上的书籍和互联网上的电子教材以及
    
                    
    • 
                    
  • Netty 知识目录
                        王小工
javajava
                        
    Netty知识结构NettyBootstrap/ServerBootstrapNettyEventLoopGroup/EventLoopNettyChannelNettyChannelPipeline/ChannelHandlerNettyByteBufNettyTCPNettyUDPNettyHTTPNettyWebsocketNettySSL/TLS
    
                    
    • 
                    
  • elasticsearch简单介绍
                        甜美河边的钓鱼人
elasticsearch
                        
    1、elasticsearch简单介绍elasticsearch是基于操作文档的搜索引擎，里面使用了netty，luncen相关技术。它可以用作站内搜索，也可以结合Logstash，kibana等技术进行日志收集分析，使用聚合技术可以进行各种数据的聚合，并且和kibana一起展示条形图，饼图，map地理分布等功能。1.1、elasticsearch的安装因为是练习用的，所以我直接使用windows
    
                    
    • 
                    
  • Netty UDP
                        王小工
javaudp网络协议网络javanio
                        
    Netty在UDP（用户数据报协议，UserDatagramProtocol）通信中的应用非常广泛，特别是在对实时性要求较高、对数据准确性要求相对较低的场景中，如视频传输、语音通信等。以下是对Netty在UDP通信中的详细解析：一、UDP协议简介UDP是一种无连接的协议，它并不在通信双方之间建立连接，而是直接将数据包从发送端发送到接收端。UDP不保证数据包的可靠传输，也不保证数据包的顺序，因此其传
    
                    
    • 
                    
  • 【四、使用Netty编写UDP应用】
                        ThinkLess404
Netty网络编程udp网络协议网络
                        
    编写UDP应用目标创建UDPServer创建ServerHandler创建UDP客户端创建客户端的Handler目标之前的章节我们学习了编码服务端，使用TCP通信，本章我们学习如何使用Netty构建一个UDP应用。创建UDPServerpackagecom.coman404.base;importcom.coman404.base.handler.UDPServerHandler;importio
    
                    
    • 
                    
  • linux部署jar项目报错_linux jar 服务
                        国家级做梦冠军
linux部署jar项目报错
                        
    关于linuxjar服务的搜索结果问题linux重启netty服务一些问题，请大神进linux上部署netty架构的服务时我一般启动的时候用下面脚本nohupjava-jarxxx-xxx.jarstart80808888&关闭的时候杀进程就可以了。今天部署的时候启动服务就报userBind，于是我查...杨冬芳2019-12-0120:26:501161浏览量回答数0问题Linux下Tomcat
    
                    
    • 
                    
  • Spring Cloud全解析：网关之GateWay简介
                        拾光师
springcloudjava
                        
    GateWay简介由于zuul升级为zuul2时，netflix公司内部出现了分歧，所以springcloud自己研发了一套网关gateway，提供一种简单有效的方式来对API进行路由，以及提供一些强大的过滤器功能，如：熔断、限流、重试等，基于WebFlux框架实现的，底层使用了高性能的Reactor模式通信框架Netty特性基于spring5和springboot2构建动态路由：能够匹配任何请求
    
                    
    • 
                    
  • Netty+WebSocket实现高并发网络编程
                        Sunny_yiyi
Java精英阶级JavaWebSocket网络websocket网络协议
                        
    我们来实现一个Netty+WebSocket集成案例，由于Netty+WebSocket集成代码比较麻烦，我们可以利用目前开源的项目netty-websocket-spring-boot-starter轻松实现Netty和WebSocket的集成。我们搭建一个项目，项目叫seckill-message，用于处理通知用户抢单状态。1)pom.xmlorg.yeauty</groupId
    
                    
    • 
                    
  • Spring Boot 一个极简且完整的后台框架
                        搬砖养女人
数据库架构javaspringsqltomcat
                        
    一个完整的极简后台框架，方便做小项目的时候可以快速开发。这里面多贴图片和代码，做个参考吧，代码可以下载下来自己看看，里面这套后台模板不错，喜欢的拿去。先放几张图imageimageimage项目介绍SpringBoot，实现了一个极简单的后台框架image小编提供免费的Java架构学习资料（里面有高可用、高并发、高性能及分布式、Jvm性能调优、Spring源码，MyBatis，Netty,Redi
    
                    
    • 
                    
  • netty编程
                        chenjunxu

                        
    需要导包：netty-all-4.1.25.Final或者导入依赖：io.nettynetty-all4.1.25.Final定义一个server类：publicclassHelloServer{publicstaticvoidmain(String[]args){//定义一对线程组//主线程组,用于接受客户端的连接，但是不做任何处理，跟老板一样，不做事EventLoopGroupbossGrou
    
                    
    • 
                    
  • Simple RPC - 05 从零开始设计一个客户端（下）_ 依赖倒置和SPI
                        小小工匠
【SimpleRPC】rpc网络协议网络
                        
    文章目录Pre概述依赖倒置原则与解耦设计与实现1.定义接口来隔离调用方与实现类2.实现类`DynamicStubFactory`3.调用方与实现类的解耦依赖注入与SPI的解耦依赖注入SPI（ServiceProviderInterface）总结PreSimpleRPC-01框架原理及总体架构初探SimpleRPC-02通用高性能序列化和反序列化设计与实现SimpleRPC-03借助Netty实现异
    
                    
    • 
                    
  • 使用Netty实现 WebSocket至Socket的消息转发服务
                        Leon-aHandler
websocket服务器网络协议nettyspringboot
                        
    业务需求场景：通过网页发送指令至硬件设备，并在连接过程中能够接收来自硬件设备的实时参数信息中转服务器逻辑：服务器内实现了一个websocket服务端和一个socket客户端，设置全局保存的ChannelGroup进行消息的转发。项目框架使用的是Springboot代码地址：https://github.com/Leon-aHandler/Netty-relayDemo
    
                    
    • 
                    
  • Netty Websocket
                        王小工
javawebsocketjavanio
                        
    一、WebSocket协议概述WebSocket是一种在单个TCP连接上进行全双工通信的协议。它允许服务端主动向客户端推送数据，从而实现了实时通信。WebSocket建立在HTTP之上，但与HTTP的轮询（Polling）和长轮询（LongPolling）相比，WebSocket只需一次握手，即可在客户端和服务器之间建立持久的连接，并通过这个连接进行双向数据传输。二、Netty框架简介Netty是
    
                    
    • 
                    
  • Netty 实现 WebSocket 协议
                        最业余的程序猿
nettywebsocket网络协议网络
                        
    要使用Netty框架实现WebSocket服务端与客户端通信，你需要按照以下步骤进行：1、添加依赖首先，在你的项目中引入Netty和其WebSocket支持库的依赖。如果你使用Maven构建项目，可以在pom.xml文件中添加相应的依赖项。Maven:io.nettynetty-all4.1.77.Finalorg.springframework.bootspring-boot-starter-w
    
                    
    • 
                                
  • Java 并发包之线程池和原子计数
                                    lijingyao8206
Java计数ThreadPool并发包java线程池
                                    
    对于大数据量关联的业务处理逻辑，比较直接的想法就是用JDK提供的并发包去解决多线程情况下的业务数据处理。线程池可以提供很好的管理线程的方式，并且可以提高线程利用率，并发包中的原子计数在多线程的情况下可以让我们避免去写一些同步代码。 
    这里就先把jdk并发包中的线程池处理器ThreadPoolExecutor 以原子计数类AomicInteger 和倒数计时锁C
    
                                
    • 
                                
  • java编程思想 抽象类和接口
                                    百合不是茶
java抽象类接口
                                    
    接口c++对接口和内部类只有简介的支持,但在java中有队这些类的直接支持 
  
1 ,抽象类 :  如果一个类包含一个或多个抽象方法,该类必须限定为抽象类(否者编译器报错) 
  
抽象方法 : 在方法中仅有声明而没有方法体  
  
 
package com.wj.Interface;


    
                                
    • 
                                
  • [房地产与大数据]房地产数据挖掘系统
                                    comsci
数据挖掘
                                    
     
       随着一个关键核心技术的突破,我们已经是独立自主的开发某些先进模块,但是要完全实现,还需要一定的时间... 
 
       所以,除了代码工作以外,我们还需要关心一下非技术领域的事件..比如说房地产 
 
    &nb
    
                                
    • 
                                
  • 数组队列总结
                                    沐刃青蛟
数组队列
                                    
      
    数组队列是一种大小可以改变，类型没有定死的类似数组的工具。不过与数组相比，它更具有灵活性。因为它不但不用担心越界问题，而且因为泛型（类似c++中模板的东西）的存在而支持各种类型。 
  
   以下是数组队列的功能实现代码： 
  
import List.Student;

public class
    
                                
    • 
                                
  • Oracle存储过程无法编译的解决方法
                                    IT独行者
oracle存储过程　
                                    
    今天同事修改Oracle存储过程又导致2个过程无法被编译，流程规范上的东西，Dave 这里不多说，看看怎么解决问题。 
   


1.     查看无效对象  
XEZF@xezf(qs-xezf-db1)> select object_name,object_type,status from all_objects where status='IN
    
                                
    • 
                                
  • 重装系统之后oracle恢复
                                    文强chu
oracle
                                    
    前几天正在使用电脑，没有暂停oracle的各种服务。 
突然win8.1系统奔溃，无法修复，开机时系统 提示正在搜集错误信息，然后再开机，再提示的无限循环中。 
无耐我拿出系统u盘 准备重装系统，没想到竟然无法从u盘引导成功。 
晚上到外面早了一家修电脑店，让人家给装了个系统，并且那哥们在我没反应过来的时候， 
直接把我的c盘给格式化了 并且清理了注册表，再装系统。 
然后的结果就是我的oracl
    
                                
    • 
                                
  • python学习二（ 一些基础语法）
                                    小桔子
pthon基础语法
                                    
    紧接着把！昨天没看继续看django 官方教程，学了下python的基本语法 与c类语言还是有些小差别： 
1.ptyhon的源文件以UTF-8编码格式 
2. 
 /   除 结果浮点型 
 //  除 结果整形 
 %   除 取余数 
 *   乘 
 **  乘方 eg 5**2 结果是5的2次方25 
 _&
    
                                
    • 
                                
  • svn 常用命令
                                    aichenglong
SVN版本回退
                                    
    1 svn回退版本 
  1)在window中选择log,根据想要回退的内容,选择revert this version或revert chanages from this version 
 两者的区别: 
  revert this version:表示回退到当前版本(该版本后的版本全部作废) 
  revert chanages from this versio
    
                                
    • 
                                
  • 某小公司面试归来
                                    alafqq
面试
                                    
    先填单子，还要写笔试题，我以时间为急，拒绝了它。。时间宝贵。 
老拿这些对付毕业生的东东来吓唬我。。 
 
面试官很刁难，问了几个问题，记录下； 
 
1，包的范围。。。public,private,protect. --悲剧了 
2，hashcode方法和equals方法的区别。谁覆盖谁.结果，他说我说反了。 
3，最恶心的一道题，抽象类继承抽象类吗？（察，一般它都是被继承的啊） 
4，stru
    
                                
    • 
                                
  • 动态数组的存储速度比较 集合框架
                                    百合不是茶
集合框架
                                    
    集合框架： 
自定义数据结构(增删改查等) 
package 数组;

/**
 * 创建动态数组
 * @author 百合
 *
 */

public class ArrayDemo{
	
	//定义一个数组来存放数据
	
	String[] src = new String[0];
	
	/**
	 * 增加元素加入容器 
	 * @param s要加入容器
    
                                
    • 
                                
  • 用JS实现一个JS对象，对象里有两个属性一个方法
                                    bijian1013
js对象
                                    
    <html> 
  <head> 
  </head> 
  <body> 
    用js代码实现一个js对象，对象里有两个属性，一个方法 
  </body> 
  <script> 
        var obj={a:'1234567',b:'bbbbbbbbbb',c:function(x){ 
 
    
                                
    • 
                                
  • 探索JUnit4扩展：使用Rule
                                    bijian1013
java单元测试JUnitRule
                                    
            在上一篇文章中，讨论了使用Runner扩展JUnit4的方式，即直接修改Test Runner的实现(BlockJUnit4ClassRunner)。但这种方法显然不便于灵活地添加或删除扩展功能。下面将使用JUnit4.7才开始引入的扩展方式——Rule来实现相同的扩展功能。 
1. Rule 
      &n
    
                                
    • 
                                
  • [Gson一]非泛型POJO对象的反序列化
                                    bit1129
POJO
                                    
    当要将JSON数据串反序列化自身为非泛型的POJO时，使用Gson.fromJson(String, Class)方法。自身为非泛型的POJO的包括两种： 
1. POJO对象不包含任何泛型的字段 
2. POJO对象包含泛型字段，例如泛型集合或者泛型类 
 Data类 a.不是泛型类， b.Data中的集合List和Map都是泛型的 c.Data中不包含其它的POJO   
 
    
                                
    • 
                                
  • 【Kakfa五】Kafka Producer和Consumer基本使用
                                    bit1129
kafka
                                    
    0.Kafka服务器的配置 
一个Broker， 
一个Topic 
Topic中只有一个Partition（）   1. Producer： 
package kafka.examples.producers;


import kafka.producer.KeyedMessage;
import kafka.javaapi.producer.Producer;
impor
    
                                
    • 
                                
  • lsyncd实时同步搭建指南——取代rsync+inotify
                                    ronin47

                                    
    1. 几大实时同步工具比较 1.1 inotify + rsync 
最近一直在寻求生产服务服务器上的同步替代方案，原先使用的是 inotify + rsync，但随着文件数量的增大到100W+，目录下的文件列表就达20M，在网络状况不佳或者限速的情况下，变更的文件可能10来个才几M，却因此要发送的文件列表就达20M，严重减低的带宽的使用效率以及同步效率；更为要紧的是，加入inotify
    
                                
    • 
                                
  • java-9. 判断整数序列是不是二元查找树的后序遍历结果
                                    bylijinnan
java
                                    
    

public class IsBinTreePostTraverse{
	
	static boolean isBSTPostOrder(int[] a){
		if(a==null){
			return false;
		}
		/*1.只有一个结点时，肯定是查找树
		 *2.只有两个结点时，肯定是查找树。例如{5,6}对应的BST是   6		{6,5}对应的BST是
    
                                
    • 
                                
  • MySQL的sum函数返回的类型
                                    bylijinnan
javaspringsqlmysqljdbc
                                    
    今天项目切换数据库时，出错 
 
访问数据库的代码大概是这样： 
 

String sql =  "select sum(number) as sumNumberOfOneDay from tableName";
List<Map> rows = getJdbcTemplate().queryForList(sql);
for (Map row : rows
    
                                
    • 
                                
  • java设计模式之单例模式
                                    chicony
java设计模式
                                    
      
在阎宏博士的《JAVA与模式》一书中开头是这样描述单例模式的： 
　　作为对象的创建模式，单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。  单例模式的结构
  
　　单例模式的特点： 
 
 单例类只能有一个实例。 
 单例类必须自己创建自己的唯一实例。 
 单例类必须给所有其他对象提供这一实例。 
 　　饿汉式单例类 
  
publ
    
                                
    • 
                                
  • javascript取当月最后一天
                                    ctrain
JavaScript
                                    
    
<!--javascript取当月最后一天-->
<script   language=javascript>  
  var current = new Date();
  var year = current.getYear();
  var month = current.getMonth();
  showMonthLastDay(year, mont
    
                                
    • 
                                
  • linux tune2fs命令详解
                                    daizj
linuxtune2fs查看系统文件块信息
                                    
    一.简介： 
tune2fs是调整和查看ext2/ext3文件系统的文件系统参数，Windows下面如果出现意外断电死机情况，下次开机一般都会出现系统自检。Linux系统下面也有文件系统自检，而且是可以通过tune2fs命令，自行定义自检周期及方式。 
二.用法： 
Usage: tune2fs [-c max_mounts_count] [-e errors_behavior] [-g grou
    
                                
    • 
                                
  • 做有中国特色的程序员
                                    dcj3sjt126com
程序员
                                    
      
从出版业说起  网络作品排到靠前的，都不会太难看，一般人不爱看某部作品也是因为不喜欢这个类型，而此人也不会全不喜欢这些网络作品。究其原因，是因为网络作品都是让人先白看的，看的好了才出了头。而纸质作品就不一定了，排行榜靠前的，有好作品，也有垃圾。   许多大牛都是写了博客，后来出了书。这些书也都不次，可能有人让为不好，是因为技术书不像小说，小说在读故事，技术书是在学知识或温习知识，有
    
                                
    • 
                                
  • Android：TextView属性大全
                                    dcj3sjt126com
textview
                                    
    android:autoLink    设置是否当文本为URL链接/email/电话号码/map时，文本显示为可点击的链接。可选值(none/web/email/phone/map/all)  android:autoText    如果设置，将自动执行输入值的拼写纠正。此处无效果，在显示输入法并输
    
                                
    • 
                                
  • tomcat虚拟目录安装及其配置
                                    eksliang
tomcat配置说明tomca部署web应用tomcat虚拟目录安装
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2097184 
1.-------------------------------------------tomcat  目录结构 
 
 config：存放tomcat的配置文件 
 temp  ：存放tomcat跑起来后存放临时文件用的 
 work   ： 当第一次访问应用中的jsp
    
                                
    • 
                                
  • 浅谈：APP有哪些常被黑客利用的安全漏洞
                                    gg163
APP
                                    
    首先，说到APP的安全漏洞，身为程序猿的大家应该不陌生；如果抛开安卓自身开源的问题的话，其主要产生的原因就是开发过程中疏忽或者代码不严谨引起的。但这些责任也不能怪在程序猿头上，有时会因为BOSS时间催得紧等很多可观原因。由国内移动应用安全检测团队爱内测（ineice.com）的CTO给我们浅谈关于Android 系统的开源设计以及生态环境。 
1. 应用反编译漏洞：APK 包非常容易被反编译成可读
    
                                
    • 
                                
  • C#根据网址生成静态页面
                                    hvt
Web.netC#asp.nethovertree
                                    
    HoverTree开源项目中HoverTreeWeb.HVTPanel的Index.aspx文件是后台管理的首页。包含生成留言板首页，以及显示用户名，退出等功能。根据网址生成页面的方法： 
  
bool CreateHtmlFile(string url, string path)
{ 
//http://keleyi.com/a/bjae/3d10wfax.htm

stri
    
                                
    • 
                                
  • SVG 教程 （一）
                                    天梯梦
svg
                                    
    SVG 简介   
SVG 是使用 XML 来描述二维图形和绘图程序的语言。  学习之前应具备的基础知识： 
继续学习之前，你应该对以下内容有基本的了解： 
 
 HTML 
 XML 基础 
 
如果希望首先学习这些内容，请在本站的首页选择相应的教程。  什么是SVG？ 
 
 SVG 指可伸缩矢量图形 (Scalable Vector Graphics) 
 SVG 用来定义用于网络的基于矢量
    
                                
    • 
                                
  • 一个简单的java栈
                                    luyulong
java数据结构栈
                                    
    
public class MyStack {
	private long[] arr;

	private int top;

	public MyStack() {
		arr = new long[10];
		top = -1;
	}

	public MyStack(int maxsize) {
		arr = new long[maxsize];
		top 
    
                                
    • 
                                
  • 基础数据结构和算法八：Binary search
                                    sunwinner
AlgorithmBinary search
                                    
    Binary search needs an ordered array so that it can use array indexing to dramatically reduce the number of compares required for each search, using the classic and venerable binary search algori
    
                                
    • 
                                
  • 12个C语言面试题，涉及指针、进程、运算、结构体、函数、内存，看看你能做出几个！
                                    刘星宇
c面试
                                    
    12个C语言面试题，涉及指针、进程、运算、结构体、函数、内存，看看你能做出几个！ 
1.gets()函数 
问：请找出下面代码里的问题： 
#include<stdio.h> 
int main(void) 
{ 
    char buff[10]; 
    memset(buff,0,sizeof(buff)); 
 

    
                                
    • 
                                
  • ITeye 7月技术图书有奖试读获奖名单公布
                                    ITeye管理员
活动ITeye试读
                                    
    ITeye携手人民邮电出版社图灵教育共同举办的7月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。 
 
 
7月试读活动回顾： 
http://webmaster.iteye.com/blog/2092746 
 
 
本次技术图书试读活动的优秀奖获奖名单及相应作品如下（优秀文章有很多，但名额有限，没获奖并不代表不优秀）： 
 
 
《Java性能优化权威指南》 
 
 
    
                                
    •