Netty框架原理

用这张图表示的就是一个基本的Netty框架

通过创建两个线程池，一个负责接入，一个负责处理

public class Start {
    public static void main(String[] args) {
            
        //初始化线程
        NioSelectorRunnablePool nioSelectorRunnablePool = new NioSelectorRunnablePool(Executors.newCachedThreadPool(), Executors.newCachedThreadPool());   //1
        
        //获取服务类
        ServerBootstrap bootstrap = new ServerBootstrap(nioSelectorRunnablePool);
        
        //绑定端口
        bootstrap.bind(new InetSocketAddress(80));
        
        System.out.println("start");
    }
}

NioSelectorRunnablePool  相当于一个线程池操作类

public class NioSelectorRunnablePool {
    
    /**
     * boss 线程数组
     */
    private final AtomicInteger bossIndex = new AtomicInteger();
    private Boss[] bosses;
    
    /**
     * worker线程数组
     */
    private final AtomicInteger workerIndex = new AtomicInteger();
    private Worker[] workers;

    public NioSelectorRunnablePool(Executor boss, Executor worker) {
        //初始化boss线程  即接入线程 
        initBoss(boss, 1);
        //根据当前核心数*2 初始化处理线程
        initWorker(worker, Runtime.getRuntime().availableProcessors() * 2);
    }

    /**
     * 初始化boss线程组
     * @param boss
     * @param count
     */
    private void initBoss(Executor boss, int count) {
        this.bosses = new NioServerBoss[count];
        for (int i = 0; i < bosses.length; i++) {
            //线程池数组
            bosses[i] = new NioServerBoss(boss, "boss thread" + (i+1), this);
        }
    }

    /**
     * 初始化worker线程
     * @param worker worker线程池
     * @param count 线程数
     */
    private void initWorker(Executor worker, int count) {
        this.workers = new NioServerWorker[count];
        for (int i = 0; i < bosses.length; i++) {
            workers[i] = new NioServerWorker(worker, "worker thread" + (i+1), this);
        }        
    }
    
    /**
     * 获取下一个boss线程
     * @return
     */
    public Boss nextBoss() {
        return bosses[Math.abs(bossIndex.getAndIncrement() % bosses.length)];
    }
    
    /**
     * 获取下一个work线程
     * @return
     */
    public Worker nextWorkr() {
        return workers[Math.abs(workerIndex.getAndIncrement() % workers.length)];
    }
}

初始化两个线程池 NioServerBoss 和NioServerWorker  两个类都实现 各自的Boss  和 Worker 接口   继承 了 AbstractNioSelector 抽象Selector

public interface Boss {
    
    /**
     * 加入一个新的ServerSocket
     * @param serverChannel
     */
    public void registerAcceptChannelTask(ServerSocketChannel serverChannel);
}

Boos