netty-经典三种IO模式

经典三种IO模式

• BIO模式（阻塞IO）:类比去食堂吃饭，BIO模式相当于排队取菜
• NIO模式（非阻塞IO）:去食堂吃饭，NIO模式相当于等待服务员将菜准备好后，通知你去取菜
• AIO模式（异步模式）:去食堂吃饭，AIO模式相当于包厢，等待服务员上菜

阻塞与非阻塞，同步与异步

• 阻塞:类比去食堂吃饭，阻塞相当于排队取菜，智能排队
• 非阻塞:去食堂吃饭非阻塞相当于等待服务员将菜准备好后，通知你去取菜，在等待过程中可以去做别的事情
• 同步:去食堂吃饭，食堂服务员打菜，你必须等到食堂服务员打菜完毕
• 异步:去食堂吃饭，食堂服务员打菜，打完后叫你说打完了，这个呼叫就是回调

BIO与NIO比较

• BIO代码简单
• 特定场景:在连接数少，并发度低，BIO性能不低于NIO

netty对BIO的支持

netty支持BIO使用OioServerSocketChannel，在创建EventLoopGroup的时候，创建OioEventLoopGroup类，并且设置channel时，设置OioServerSocketChannel

 EventLoopGroup bossGroup = new OioEventLoopGroup(1);
        EventLoopGroup workerGroup = new OioEventLoopGroup();
        final EchoServerHandler serverHandler = new EchoServerHandler();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
             .channel(OioServerSocketChannel.class)
             .option(ChannelOption.SO_BACKLOG, 100)
             .handler(new LoggingHandler(LogLevel.INFO))
             .childHandler(new ChannelInitializer<SocketChannel>() {
                 @Override
                 public void initChannel(SocketChannel ch) throws Exception {
                     ChannelPipeline p = ch.pipeline();
                     if (sslCtx != null) {
                         p.addLast(sslCtx.newHandler(ch.alloc()));
                     }
                     //p.addLast(new LoggingHandler(LogLevel.INFO));
                     p.addLast(serverHandler);
                 }
             });

netty对reactor的支持

• 什么是reactor：reactor设计模式是event-driven architecture的一种实现方式，处理多个客户端并发的向服务端请求服务的场景。每种服务在服务端可能由多个方法组成。reactor会解耦并发请求的服务并分发给对应的事件处理器来处理
• reactor的三种模式
  1.单线程模式:单Reactor单线程模型，负责多路分离套接字，Accept新连接，并分派请求到Handler处理器中，但是单线程模式的缺点1.当其中某个handler阻塞时，会导致其他所有的client的handler都得不到执行，而且如果handler的阻塞也会导致整个服务不能接受到新的请求
  2.多线程模式：基于单线程基础上，我们把handler处理器的执行放到线程池中，多线程进行业务处理，
  
  3.主从多线程模式：在多线程reactor模式下，我们把reactor分文两个，一个reactor用于接收连接，一个用于进行read和send
  
• netty如何支持三种模式
  1.单线程模式：只有一个NioEventLoopGroup

EventLoopGroup workerGroup = new NioEventLoopGroup(1);
        final EchoServerHandler serverHandler = new EchoServerHandler();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(workerGroup) 
             .channel(NioServerSocketChannel.class)
             .option(ChannelOption.SO_BACKLOG, 100)
             .handler(new LoggingHandler(LogLevel.INFO))
             .childHandler(new ChannelInitializer<SocketChannel>() {
                 @Override
                 public void initChannel(SocketChannel ch) throws Exception {
                     ChannelPipeline p = ch.pipeline();
                     if (sslCtx != null) {
                         p.addLast(sslCtx.newHandler(ch.alloc()));
                     }
                     //p.addLast(new LoggingHandler(LogLevel.INFO));
                     p.addLast(serverHandler);
                 }
             });
            // Start the server.
            ChannelFuture f = b.bind(PORT).sync();
            // Wait until the server socket is closed.
            f.channel().closeFuture().sync();

2.多线程模式：

EventLoopGroup workerGroup = new NioEventLoopGroup();//多线程
        final EchoServerHandler serverHandler = new EchoServerHandler();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(workerGroup, workerGroup) 
             .channel(NioServerSocketChannel.class)
             .option(ChannelOption.SO_BACKLOG, 100)
             .handler(new LoggingHandler(LogLevel.INFO))
             .childHandler(new ChannelInitializer<SocketChannel>() {
                 @Override
                 public void initChannel(SocketChannel ch) throws Exception {
                     ChannelPipeline p = ch.pipeline();
                     if (sslCtx != null) {
                         p.addLast(sslCtx.newHandler(ch.alloc()));
                     }
                     //p.addLast(new LoggingHandler(LogLevel.INFO));
                     p.addLast(serverHandler);
                 }
             });
            // Start the server.
            ChannelFuture f = b.bind(PORT).sync();
            // Wait until the server socket is closed.
            f.channel().closeFuture().sync();

3.主从多线程模式：bossGroup 用于accpet用户连接 workerGroup 用于read和send

EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        final EchoServerHandler serverHandler = new EchoServerHandler();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup , workerGroup)
             .channel(NioServerSocketChannel.class)
             .option(ChannelOption.SO_BACKLOG, 100)
             .handler(new LoggingHandler(LogLevel.INFO))
             .childHandler(new ChannelInitializer<SocketChannel>() {
                 @Override
                 public void initChannel(SocketChannel ch) throws Exception {
                     ChannelPipeline p = ch.pipeline();
                     if (sslCtx != null) {
                         p.addLast(sslCtx.newHandler(ch.alloc()));
                     }
                     //p.addLast(new LoggingHandler(LogLevel.INFO));
                     p.addLast(serverHandler);
                 }
             });
            // Start the server.
            ChannelFuture f = b.bind(PORT).sync();

相关问题

• 为什么说netty的main reactor 大多并不能用到一个线程组，只能线程里面一个
  netty因为服务启动的时候只绑定了一个端口，所以将会在EventLoopGroup中选择一个eventLoop去注册事件。