netty问题清单

深碍√TFBOYSˉ_ 2023-06-26 12:16 22阅读 0赞

### netty问题清单 ###

*  netty写一个服务器
 *  bio为何每个连接都要new一个线程去处理
 *  代码实现单线程的nio
 *  如何实现响应式的nio【单线程+线程池的nio】【NIO-reactor模式】
 *  nio和消息队列有啥关系
 *  有了AIO，为何还有nio
 *  netty

# netty写一个服务器 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70]

# bio为何每个连接都要new一个线程去处理 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 1]

while(true){ 
     Socket socket = socket.accept()  //阻塞
     new Thread(new Runable(){ @override ....}).start();
     //假如一堆请求任务的处理时间是[10,5,1,20,3]，现在这个5个请求都同时发起了，如果对每个连接都直接进行处理，那么客户端的平均等待时间就是（10+15+16+36+39）/5=23.2秒
     //使用了多线程后：客户端的平均等待时间就是（10+5+1+20+3）/5=7.8秒
     //由此可见：每个连接都必需要new一个线程去处理
    socket.getInputStream().read(new byte[1024])  //阻塞的
    socket.getOutputStream().write(new byte[1024],0,len)  //阻塞的
    
    //如此多的阻塞，就导致大多数的线程在哪停着，cpu还要频繁的在这些线程之间来回的切换
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 2]

# 代码实现单线程的nio #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 3]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 4]  
一个线程去处理连接，读入，写出这些事，它在阻塞阶段就会隔一段时间就去查询一些，它所等待的那些（感兴趣的事：即有无新的连接，读入，写出等事件）有没有发生，发生了，就被唤醒去处理这些事。

> 一个连接就是一个通道  
> 单线程的nio是只有一个大管家

> ServerSocketChannel是对ServerSocket逻辑上的封装，它是双向的，支持同时读入和写出。服务端有很多的插口，selector会对这些插口标记上一个key。（一个key就是一个事件）。即selector往插口上扔的监听器

> accept()是建立通道。selector是等待事件的发生  
> bio是byte为单位，nio是buffer为单位  
> 对于单线程的selector，如果读写阻塞了，那么selector将不能再处理新的连接了

[代码理解的参考链接][Link 1]

ServerSocketChannel ssc = ServerSocketChannel.open();   //bio中是ServerSocket，nio封装后就是ServerSocketChannel，//新建NIO通道
            ssc.socket().bind(new InetSocketAddress("127.0.0.1", 8888));//设置初值，//创建基于NIO通道的socket连接，//新建socket通道的端口
            ssc.configureBlocking(false);//;//使通道为非阻塞
    
            System.out.println("server started, listening on :" + ssc.getLocalAddress());
            Selector selector = Selector.open();
            ssc.register(selector, SelectionKey.OP_ACCEPT);将NIO通道绑定到选择器,当然绑定后分配的主键为skey
    
            while(true) { 
                selector.select();获取通道内是否有选择器的关心事件, 意思是有多少学生报告
                Set<SelectionKey> keys = selector.selectedKeys();获取通道内关心事件的集合 ，这里的集合就是老师和学生的编号集合，如果key是学生的，那就是老学生来问问题，如果key是老师的，那就是招生办的老师带着一个新生来注册
                Iterator<SelectionKey> it = keys.iterator();
                while(it.hasNext()) { 遍历每个key （学生key和老师key）
                    SelectionKey key = it.next();
                    it.remove();
                    handle(key);
                }
            }
    
        }
    
        private static void handle(SelectionKey key) { 
            if(key.isAcceptable()) { 
                try { 
                    ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
                    SocketChannel sc = ssc.accept(); //判断是新生，监听连接事件
                    sc.configureBlocking(false);
                 
                    sc.register(key.selector(), SelectionKey.OP_READ );//判断是老生，即已建立连接，监听读事件
                } catch (IOException e) { 
                    e.printStackTrace();
                } finally { 
                }
            } else if (key.isReadable()) {  //flip
                SocketChannel sc = null;
                try { 
                    sc = (SocketChannel)key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(512);
                    buffer.clear();
                    int len = sc.read(buffer);
    
                    if(len != -1) { 
                        System.out.println(new String(buffer.array(), 0, len));
                    }
    
                    ByteBuffer bufferToWrite = ByteBuffer.wrap("HelloClient".getBytes());
                    sc.write(bufferToWrite);
                } catch (IOException e) { 
                    e.printStackTrace();
                } finally { 
                    if(sc != null) { 
                        try { 
                            sc.close();
                        } catch (IOException e) { 
                            e.printStackTrace();
                        }
                    }
                }

# 如何实现响应式的nio【单线程+线程池的nio】【NIO-reactor模式】 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 5]

> 响应式的nio是一个大管家（selector）领着线程池里的一堆工人（线程）。它不是每个客户端分配一个线程，而是把一堆客户端分配给一个线程池（一堆线程在哪等着，有人要读吗，有人要写吗，selector查询到有一个，蹦，给你，你去处理，你空着的，蹦，给你，你去处理）—即boss和worker【netty就是对这个模型的封装】----------单线程+线程池

ExecutorService pool = Executors.newFixedThreadPool(50);  //启动50个线程
    
        private Selector selector;
        //中文测试
    
        /** * * @throws IOException */
        public static void main(String[] args) throws IOException { 
            PoolServer server = new PoolServer();
            server.initServer(8000);
            server.listen();
        }
    
        /** * * @param port * @throws IOException */
        public void initServer(int port) throws IOException { 
            //
            ServerSocketChannel serverChannel = ServerSocketChannel.open();
            //
            serverChannel.configureBlocking(false);
            //
            serverChannel.socket().bind(new InetSocketAddress(port));
            //
            this.selector = Selector.open();
    
            serverChannel.register(selector, SelectionKey.OP_ACCEPT);
            System.out.println("服务端启动成功！");
        }
    
        /** * * @throws IOException */
        @SuppressWarnings("unchecked")
        public void listen() throws IOException { 
            // 轮询访问selector 
            while (true) { 
                //
                selector.select();
                //
                Iterator ite = this.selector.selectedKeys().iterator();
                while (ite.hasNext()) { 
                    SelectionKey key = (SelectionKey) ite.next();
                    //
                    ite.remove();
                    //
                    if (key.isAcceptable()) { 
                        ServerSocketChannel server = (ServerSocketChannel) key.channel();
                        //
                        SocketChannel channel = server.accept();
                        //
                        channel.configureBlocking(false);
                        //
                        channel.register(this.selector, SelectionKey.OP_READ);//注册读事件
                        //
                    } else if (key.isReadable()) { 
                        //
                        key.interestOps(key.interestOps()&(~SelectionKey.OP_READ));
                        //
                        pool.execute(new ThreadHandlerChannel(key));//线程池里哪个线程空着，就让谁来处理
                    }
                }
            }
        }
    }
    
    /** * * @param * @throws IOException */
    class ThreadHandlerChannel extends Thread{ 
        private SelectionKey key;
        ThreadHandlerChannel(SelectionKey key){ 
            this.key=key;
        }
        @Override
        public void run() { 
            //
            SocketChannel channel = (SocketChannel) key.channel();
            //
            ByteBuffer buffer = ByteBuffer.allocate(1024);//非常难用的一个api，这是如此，才不用原生的java的nio，这就导致了netty的火爆，它就是因为解决了ByteBuffer的api难用的这个问题而火爆了起来，成为了最流行的网络编程框架。
            //
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            try { 
                int size = 0;
                while ((size = channel.read(buffer)) > 0) { 
                    buffer.flip();
                    baos.write(buffer.array(),0,size);
                    buffer.clear();
                }
                baos.close();
                //
                byte[] content=baos.toByteArray();
                ByteBuffer writeBuf = ByteBuffer.allocate(content.length);
                writeBuf.put(content);
                writeBuf.flip();
                channel.write(writeBuf);//
                if(size==-1){ 
    
                    channel.close();
                }else{ 
                    //
                    key.interestOps(key.interestOps()|SelectionKey.OP_READ);
                    key.selector().wakeup();
                }
            }catch (Exception e) { 
                System.out.println(e.getMessage());
            }
        }

# nio和消息队列有啥关系 #

消息队列：客户端疯狂向服务端发消息，服务端的线程对这些消息未必处理的过来，解决办法就是先将这些消息存入到消息队列里面。另外的线程再不断地将这些消息拿过来做处理。（就是一个消息暂存器）—一个连接一个队列。通道是客户端和服务端通信地一个虚拟地通道，读入，写出，读入，写出。通道是对serversocket地封装。通道和队列是完全两个不同地概念

# 有了AIO，为何还有nio #

> 在linux底层，aio和nio都是用epoll【他是底层编程的一种模型，epoll是轮询模型，aio是又加了一层轮询9又包了一层，aio的api更好用），无论上层如何封装，底层都是轮询，故不如直接使用nio】实现的。netty封装的是nio（功能已足够强大，但api不好用），它的api更像aio（api更好用）

NIO是有事没事都在轮询（转一圈）。AIO是有事了你再通知我，我再去轮询。（这里面是操作系统底层的实现了，这个通知是由操作系统/内核来发起通知了）  
原理

> 客户端需要连接的时候，交给操作系统去连接，操作系统一旦连上了，就会通知（发一个消息）这个大管家selector。这是大管家做哪等就行。cpu的速度要比网络的速度快很多（几百万倍），（单线程能处理客户端同时百万连接）。线程并非越多越好，它会增加上下文切换的开销。网络io/磁盘io都需要os的处理

# netty #

（至少你要懂概念，要能说得出来，代码可以暂时写不来。给我点时间，稍稍练习一下，我就可以上手）如果把网络编程比作切菜，nio封装的网络模型想把斧子，netty封装的更像一把菜刀，更适合用来切菜

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200102175519926.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200102175355339.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200101143414234.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200102175334211.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200102175441444.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70
[Link 1]: https://blog.csdn.net/u010154380/article/details/64440093
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200102175241517.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDYzMTQx,size_16,color_FFFFFF,t_70