摘要：端引導(dǎo)類線程管理組線程管理組將設(shè)置到服務(wù)端引導(dǎo)類中指定通道類型為，一種異步模式，阻塞模式為設(shè)置讓服務(wù)器監(jiān)聽某個(gè)端口已等待客戶端連接。

-

1、Netty這個(gè)詞，對(duì)于熟悉并發(fā)的童鞋一點(diǎn)都不陌生，它是一個(gè)異步事件驅(qū)動(dòng)型的網(wǎng)絡(luò)通信框架；
2、使用Netty不需要我們關(guān)注過多NIO的API操作，簡簡單單的使用即可，非常方便，開發(fā)門檻較低；
3、而且Netty也經(jīng)歷了各大著名框架的“摧殘”，足以證明其性能高，穩(wěn)定性高；
4、那么本章節(jié)就來和大家分享分析一下Netty的服務(wù)端啟動(dòng)流程，分析Netty的源碼版本為：netty-netty-4.1.22.Final；

1、是一個(gè)基于NIO的客戶端、服務(wù)器端的網(wǎng)絡(luò)通信框架；

2、是一個(gè)以提供異步的、事件驅(qū)動(dòng)型的網(wǎng)絡(luò)應(yīng)用工具；

3、可以供我們快速開發(fā)高性能的、高可靠性的網(wǎng)絡(luò)服務(wù)器與客戶端；

1、開箱即用，簡單操作，開發(fā)門檻低，API簡單，只需關(guān)注業(yè)務(wù)實(shí)現(xiàn)即可，不用關(guān)心如何編寫NIO；

2、自帶多種協(xié)議棧且預(yù)置多種編解碼功能，且定制化能力強(qiáng)；

3、綜合性能高，已歷經(jīng)各大著名框架(RPC框架、消息中間件)等廣泛驗(yàn)證，健壯性非常強(qiáng)大；

4、相對(duì)于JDK的NIO來說，netty在底層做了很多優(yōu)化，將reactor線程的并發(fā)處理提到了極致；

5、社區(qū)相對(duì)較活躍，遇到問題可以隨時(shí)提問溝通并修復(fù)；

1、創(chuàng)建兩個(gè)線程管理組，一個(gè)是bossGroup，一個(gè)是workerGroup，每個(gè)Group下都有一個(gè)線程組children[i]來執(zhí)行任務(wù)；

2、bossGroup專門用來攬客的，就是接收客戶端的請(qǐng)求鏈接，而workerGroup專門用來干事的，bossGroup攬客完了就交給workerGroup去干活了；

3、通過bind輕松的一句代碼綁定注冊(cè)，其實(shí)里面一點(diǎn)都不簡單，一堆堆的操作；

4、創(chuàng)建NioServerSocketChannel，并且將此注冊(cè)到bossGroup的子線程中的多路復(fù)用器上；

5、最后一步就是將NioServerSocketChannel綁定到指定ip、port即可，由此完成服務(wù)端的整個(gè)啟動(dòng)過程；

/**
 * Netty服務(wù)端啟動(dòng)代碼。
 *
 * @author hmilyylimh
 *
 * @version 0.0.1
 *
 * @date 2018/3/25
 *
 */
public class NettyServer {

    public static final int TCP_PORT = 20000;

    private final int port;

    public NettyServer(int port) {
        this.port = port;
    }

    public void start() throws Exception {
        EventLoopGroup bossGroup = null;
        EventLoopGroup workerGroup = null;
        try {
            // Server 端引導(dǎo)類
            ServerBootstrap serverBootstrap = new ServerBootstrap();

            // Boss 線程管理組
            bossGroup = new NioEventLoopGroup(1);

            // Worker 線程管理組
            workerGroup = new NioEventLoopGroup();

            // 將 Boss、Worker 設(shè)置到 ServerBootstrap 服務(wù)端引導(dǎo)類中
            serverBootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    // 指定通道類型為NioServerSocketChannel，一種異步模式，OIO阻塞模式為OioServerSocketChannel
                    .localAddress("localhost", port)//設(shè)置InetSocketAddress讓服務(wù)器監(jiān)聽某個(gè)端口已等待客戶端連接。
                    .childHandler(new ChannelInitializer() {//設(shè)置childHandler執(zhí)行所有的連接請(qǐng)求
                        @Override
                        protected void initChannel(Channel ch) throws Exception {
                            ch.pipeline().addLast(new PacketHeadDecoder());
                            ch.pipeline().addLast(new PacketBodyDecoder());

                            ch.pipeline().addLast(new PacketHeadEncoder());
                            ch.pipeline().addLast(new PacketBodyEncoder());

                            ch.pipeline().addLast(new PacketHandler());
                        }
                    });
            // 最后綁定服務(wù)器等待直到綁定完成，調(diào)用sync()方法會(huì)阻塞直到服務(wù)器完成綁定,然后服務(wù)器等待通道關(guān)閉，因?yàn)槭褂胹ync()，所以關(guān)閉操作也會(huì)被阻塞。
            ChannelFuture channelFuture = serverBootstrap.bind().sync();
            System.out.println("Server started，port：" + channelFuture.channel().localAddress());
            channelFuture.channel().closeFuture().sync();
        } finally {
            // Shut down all event loops to terminate all threads.
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        new NettyServer(TCP_PORT).start();
    }
}

1、源碼：
    // NettyServer.java, Boss 線程管理組, 上面NettyServer.java中的示例代碼
    bossGroup = new NioEventLoopGroup(1);

    // NioEventLoopGroup.java
    /**
     * Create a new instance using the specified number of threads, {@link ThreadFactory} and the
     * {@link SelectorProvider} which is returned by {@link SelectorProvider#provider()}.
     */
    public NioEventLoopGroup(int nThreads) {
        this(nThreads, (Executor) null);
    }    
    
    // NioEventLoopGroup.java
    public NioEventLoopGroup(int nThreads, Executor executor) {
        this(nThreads, executor, SelectorProvider.provider());
    }    
    
    // NioEventLoopGroup.java
    public NioEventLoopGroup(
            int nThreads, Executor executor, final SelectorProvider selectorProvider) {
        this(nThreads, executor, selectorProvider, DefaultSelectStrategyFactory.INSTANCE);
    }    
    
    // NioEventLoopGroup.java
    public NioEventLoopGroup(int nThreads, Executor executor, final SelectorProvider selectorProvider,
                             final SelectStrategyFactory selectStrategyFactory) {
        super(nThreads, executor, selectorProvider, selectStrategyFactory, RejectedExecutionHandlers.reject());
    }    
    
    // MultithreadEventLoopGroup.java
    /**
     * @see MultithreadEventExecutorGroup#MultithreadEventExecutorGroup(int, Executor, Object...)
     */
    protected MultithreadEventLoopGroup(int nThreads, Executor executor, Object... args) {
        // DEFAULT_EVENT_LOOP_THREADS 默認(rèn)為CPU核數(shù)的2倍
        super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, args);
    }    
    
    // MultithreadEventExecutorGroup.java
    /**
     * Create a new instance.
     *
     * @param nThreads          the number of threads that will be used by this instance.
     * @param executor          the Executor to use, or {@code null} if the default should be used.
     * @param args              arguments which will passed to each {@link #newChild(Executor, Object...)} call
     */
    protected MultithreadEventExecutorGroup(int nThreads, Executor executor, Object... args) {
        this(nThreads, executor, DefaultEventExecutorChooserFactory.INSTANCE, args);
    }    
    
    // MultithreadEventExecutorGroup.java
    /**
     * Create a new instance.
     *
     * @param nThreads          the number of threads that will be used by this instance.
     * @param executor          the Executor to use, or {@code null} if the default should be used.
     * @param chooserFactory    the {@link EventExecutorChooserFactory} to use.
     * @param args              arguments which will passed to each {@link #newChild(Executor, Object...)} call
     */
    protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
                                            EventExecutorChooserFactory chooserFactory, Object... args) {
        if (nThreads <= 0) { // 小于或等于零都會(huì)直接拋異常，由此可見，要想使用netty，還得必須至少得有1個(gè)線程跑起來才能使用
            throw new IllegalArgumentException(String.format("nThreads: %d (expected: > 0)", nThreads));
        }

        if (executor == null) { // 如果調(diào)用方不想自己定制線程池的話，那么則用netty自己默認(rèn)的線程池
            executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());
        }

        children = new EventExecutor[nThreads]; // 構(gòu)建孩子結(jié)點(diǎn)數(shù)組，也就是構(gòu)建NioEventLoopGroup持有的線程數(shù)組

        for (int i = 0; i < nThreads; i ++) { // 循環(huán)線程數(shù)，依次創(chuàng)建實(shí)例化線程封裝的對(duì)象NioEventLoop
            boolean success = false;
            try {
                children[i] = newChild(executor, args); // 最終調(diào)用到了NioEventLoopGroup類中的newChild方法
                success = true;
            } catch (Exception e) {
                // TODO: Think about if this is a good exception type
                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) {
                            // Let the caller handle the interruption.
                            Thread.currentThread().interrupt();
                            break;
                        }
                    }
                }
            }
        }

        // 實(shí)例化選擇線程器，也就是說我們要想執(zhí)行任務(wù)，對(duì)于nThreads個(gè)線程，我們得靠一個(gè)規(guī)則來如何選取哪個(gè)具體線程來執(zhí)行任務(wù)；
        // 那么chooser就是來干這個(gè)事情的，它主要是幫我們選出需要執(zhí)行任務(wù)的線程封裝對(duì)象NioEventLoop
        chooser = chooserFactory.newChooser(children);

        final FutureListener