Netty是什么

1. Netty介绍

   1. Netty是一个异步的、基于事件驱动的网络应用框架，用以快速开发高性能、高可靠性的网络IO程序。
   2. Netty主要针对在TCP协议下，面向Clients端的高并发应用，或者Peer-to-Peer场景下的大量数据持续传输的应用。
   3. Netty本质是一个NIO框架，适用于服务器通讯相关的多种应用场景。
2. Netty应用场景
   1. 互联网行业：RPC框架使用、阿里Dubbo协议。
   2. 游戏行业
   3. 大数据领域
3. I/O模型
   1. BIO：同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销。适用于连接数比较小且固定的架构，这种方式对服务器要求高，并发局限于应用中。
   2. NIO：同步非阻塞，服务器实现模式为一个线程处理多个请求（连接），即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有IO请求就行处理。
      1. 三大核心部分：Channel（通道），Buffer（缓冲区），Selector（选择器）。
      2. NIO是面向缓冲或者面向块编程的。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动，这就增加了处理过程中的灵活性，使用它可以提供非阻塞式的高伸缩性网络。
   3. AIO：异步非阻塞，AIO引入异步通道的概念，采用了Proactor模式，简化了程序编写，有效的请求才启动线程，他的特点是先由操作系统完成后才通知服务端程序启动线程去处理，一般适用于连接数较多且连接时间较长的应用。
   4. BIO工作机制
      1. 原理图                                                                                                                 
      2. 简单流程
         1. 服务器端启动一个ServerSocket
         2. 客户端启动Socket对服务器进行通信，默认情况下服务器端需要对每个客户建立一个线程与之通讯
         3. 客户端发出请求后，先咨询服务器是否有线程响应，如果没有则会等待，或者被拒绝
         4. 如果有响应，客户端线程会等待请求结束后，再继续进行
      3. 问题分析
         1. 每个请求都需要创建独立的线程，与对应的客户端进行数据Read，业务处理，数据Write
         2. 当并发数较大时，需要创建大量线程来处理连接，系统资源占用较大
         3. 连接建立后，如果当前线程暂时没有数据可读，则线程就阻塞在Read操作上，造成资源浪费
      4. 应用实例
         1. 说明
            1. 使用BIO编写一个服务器端，监听6666端口，当有客户端连接时，就启动一个线程与之通讯
            2. 要求使用线程池机制改善，可以连接多个客户端。
            3. 服务器端可以接收客户端发送的数据（telnet方式即可）
         2. 代码

            public class BIOServer {
                public static void main(String[] args) throws Exception {
                    // 线程池机制
            
                    //思路
                    // 1.创建一个线程池
                    // 2.如果有客户端连接，就创建一个线程，与之通讯（单独写一个方法）
            
                    ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
            
                    // 创建ServerSocket
                    ServerSocket serverSocket = new ServerSocket(6666);
            
                    System.out.println("服务器启动了");
            
                    while (true){
                        System.out.println("线程信息id=" + Thread.currentThread().getId() + "， 名字="+Thread.currentThread().getName());
                        // 监听等待客户端连接
                        System.out.println("等待连接。。。");
                        final Socket socket = serverSocket.accept();
                        System.out.println("连接到一个客户端");
            
                        //就创建一个线程，与之通讯
                        newCachedThreadPool.execute(new Runnable() {
                            public void run() {
                                //可以和客户端通讯
                                handler(socket);
                            }
                        });
                    }
                }
            
                //编写一个handler方法，和客户端通讯
                public static void handler(Socket socket){
                    try {
                        System.out.println("线程信息id=" + Thread.currentThread().getId() + "， 名字="+Thread.currentThread().getName());
                        byte[] bytes = new byte[1024];
                        // 通过socket获取输入流
                        InputStream inputStream = socket.getInputStream();
            
                        //循环读取客户端发送的数据
                        while (true){
                            System.out.println("线程信息id=" + Thread.currentThread().getId() + "， 名字="+Thread.currentThread().getName());
                            System.out.println("read。。。");
                            int read = inputStream.read(bytes);
                            if (read != -1){
                                System.out.println(new String(bytes, 0, read)); //输出客户端发送的数据
                            }else{
                                break;
                            }
                        }
                    }catch (Exception e){
                        e.printStackTrace();
                    }finally {
                        System.out.println("关闭和client的连接");
                        try {
                            socket.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }

         3. 运行效果：cmd -> telnet 127.0.0.1 6666 -> ctrl + ] -> send content

   5. NIO基本介绍
      1. NIO与BIO的比较
         1. BIO以流的方式处理数据，而NIO以块的方式处理数据，块的效率比流高。
         2. BIO是阻塞的，NIO非阻塞。
         3. BIO基于字节流和字符流进行操作，而NIO基于Channel和Buffer进行操作，数据总是从通道读到缓冲区，或者从缓冲区写入通道。Selector用于监听多个通道的事件（eg：连接请求，数据到达等），因此使用单个线程就可以监听多个客户端通道。
      2. NIO的Buffer基本使用

         public class BasicBuffer {
             public static void main(String[] args) {
                 // 举例说明buffer的使用(简单说明)
                 // 创建一个buffer，大小为5，即可存放5个int
                 IntBuffer intBuffer = IntBuffer.allocate(5);
                 //向buffer中存放数据
                 for(int i = 0; i < intBuffer.capacity(); i++){
                     intBuffer.put(i * 2);
                 }
                 // 如何从buffer读取数据
                 // 将buffer转换，读写切换
                 intBuffer.flip();
                 while (intBuffer.hasRemaining()){
                     System.out.println(intBuffer.get());
                 }
             }
         }