[网络协议]18.Socket网络编程

JavaSE高级 网络编程

第一章 网络编程入门

1.1软件结构

• C/S结构 ：全称为Client/Server结构，是指客户端和服务器结构。常见程序有ＱＱ、迅雷等软件。

• B/S结构 ：全称为Browser/Server结构，是指浏览器和服务器结构。常见浏览器有谷歌、火狐等。

两种架构各有优势，但是无论哪种架构，都离不开网络的支持。网络编程，就是在一定的协议下，实现两台计算机的通信的程序。

1.2 网络通信协议

• **网络通信协议：**通信协议是对计算机必须遵守的规则，只有遵守这些规则，计算机之间才能进行通信。这就好比在道路中行驶的汽车一定要遵守交通规则一样，协议中对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守，最终完成数据交换。

• TCP/IP协议： 传输控制协议/因特网互联协议( Transmission Control Protocol/Internet Protocol)，是Internet最基本、最广泛的协议。它定义了计算机如何连入因特网，以及数据如何在它们之间传输的标准。它的内部包含一系列的用于处理数据通信的协议，并采用了4层的分层模型，每一层都呼叫它的下一层所提供的协议来完成自己的需求。

应用层：

HTTP： 超文本传输协议，网页传输

FTP：文件传输

SMTP：基本的邮件传输

传输层：

**TCP：**传输控制协议 (Transmission Control Protocol) 面向连接的安全的数据传输协议

UDP：用户数据报协议(User Datagram Protocol) 面向无连接的不安全的数据传输协议

**网络层：**获取本机IP，和对方机器的IP及端口号

**数据链路层：**硬件层面上

1.3 协议分类

通信的协议还是比较复杂的，java.net 包中包含的类和接口，它们提供低层次的通信细节。我们可以直接使用这些类和接口，来专注于网络程序开发，而不用考虑通信的细节。

java.net 包中提供了两种常见的网络协议的支持：

• TCP：传输控制协议 (Transmission Control Protocol)。TCP协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。
  • 三次握手：TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠。
    • 第一次握手，客户端向服务器端发出连接请求，等待服务器确认。服务器你死了吗？
    • 第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求。我活着啊！！
    • 第三次握手，客户端再次向服务器端发送确认信息，确认连接。整个交互过程如下图所示。我知道了！！

? 完成三次握手，连接建立后，客户端和服务器就可以开始进行数据传输了。由于这种面向连接的特性，TCP协议可以保证传输数据的安全，所以应用十分广泛，例如下载文件、浏览网页等。

• UDP：用户数据报协议(User Datagram Protocol)。UDP协议是一个面向无连接的协议。传输数据时，不需要建立连接，不管对方端服务是否启动，直接将数据、数据源和目的地都封装在数据包中，直接发送。每个数据包的大小限制在64k以内。它是不可靠协议，因为无连接，所以传输速度快，但是容易丢失数据。日常应用中,例如视频会议、QQ聊天等。

TCP和UDP的区别

1.TCP：传输控制协议 (Transmission Control Protocol) 面向连接的安全的数据传输协议

UDP：用户数据报协议(User Datagram Protocol) 面向无连接的不安全的数据传输协议

2.TCP协议可以保证传输数据的安全，传输速度相对较低

UDP协议它是不可靠协议，因为无连接，所以传输速度快，但是容易丢失数据。

3.TCP使用场景：文件上传、下载、消息传递等等

UDP使用场景：语音聊天、视频聊天等

1.4 网络编程三要素

协议

• **协议：**计算机网络通信必须遵守的规则，已经介绍过了，不再赘述。

IP地址

• IP地址：指互联网协议地址（Internet Protocol Address），俗称IP。IP地址用来给一个网络中的计算机设备做唯一的编号。假如我们把“个人电脑”比作“一台电话”的话，那么“IP地址”就相当于“电话号码”。

**IP地址分类 ** [][][][] o o o o

• IPv4：是一个32位的二进制数（2^32），通常被分为4个字节，表示成a.b.c.d 的形式，例如192.168.65.100 。其中a、b、c、d都是0~255之间的十进制整数，那么最多可以表示42亿个（4,294,967,296）。

  网络的分类有多种形式，从网络的地理覆盖范围可以将网络分为三类,即局域网、城域网、广域网。

  局域网： 局域网(LAN)是指在某一区域内由多台计算机相互连接形成的计算机网络,其覆盖范围为几百米到几千米之间。局域网常被用于连接公司办公室或工厂中的个人计算机,以便共享资源(例如打印机资源的共享)和交换信息。 一般多用于公司内部使用。

  城域网： 城域网(MAN),是一种大型的局域网,采用和局域网类似的技术。城域网覆盖面积比局域网略广,可以达到几十千米,其传输速率也高于局域网。 一般多用于城市之间使用。

  广域网（公网）： 广域网(WAN)也叫远程网,是一种地理范围巨大的网络,它将分布在不同地区的局域网或计算机系统互连起来,达到资源共享的目的。通常广域网的覆盖范围可达到几万千米,一般由通信公司建立和维护。例如,国家之间建立的网络都是广域网。 一般可以在全球任何地方访问。

• IPv6：由于互联网的蓬勃发展，IP地址的需求量愈来愈大，但是网络地址资源有限，使得IP的分配越发紧张。有资料显示，全球IPv4地址在2011年2月分配完毕。

  为了扩大地址空间，拟通过IPv6重新定义地址空间，采用128位地址长度，每16个字节一组，分成8组十六进制数，表示成ABCD:EF01:2345:6789:ABCD:EF01:2345:6789，号称可以为全世界的每一粒沙子编上一个网址，这样就解决了网络地址资源数量不够的问题。

常用命令

• 查看本机IP地址，在控制台输入：

ipconfig

• 检查网络是否连通，在控制台输入：

ping 空格 IP地址
ping 220.181.57.216   //IP
ping www.baidu.com    //域名

特殊的IP地址

• 本机IP地址：127.0.0.1、localhost 。不受环境的影响，任何时候都存在这两个IP，可以直接找本机。

端口号

网络的通信，本质上是两个进程（应用程序）的通信。每台计算机都有很多的进程，那么在网络通信时，如何区分这些进程呢？

如果说IP地址可以唯一标识网络中的设备，那么端口号就可以唯一标识设备中的进程（应用程序）了。

• **端口号：用两个字节表示的整数，它的取值范围是0_{65535**。其中，0}1023之间的端口号用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败。

利用协议+IP地址+端口号 三元组合，就可以标识网络中的进程了，那么进程间的通信就可以利用这个标识与其它进程进行交互。

1.5 InetAddress类

1.5.1 概述

一个该类的对象就代表一个IP地址对象。

1.5.2 InetAddress类成员方法

//获得本地主机IP地址对象
static InetAddress getLocalHost()  

//根据IP地址字符串或主机名获得对应的IP地址对象
static InetAddress getByName(String host)  

//获得主机名   
String getHostName()    

//获得IP地址字符串
String getHostAddress()  

1.5.3 案例

public class InetAddressDemo01 {
    public static void main(String[] args) throws Exception {
        // 获得本地主机IP地址对象
        InetAddress inet01 = InetAddress.getLocalHost();
        // ztsdeMacBook-Pro.local/192.168.3.20
        // 主机名/ip地址字符串
        System.out.println(inet01);
        
        // 根据IP地址字符串或主机名获得对应的IP地址对象
        // InetAddress inet02 = InetAddress.getByName("192.168.3.20");
        InetAddress inet02 = InetAddress.getByName("baidu.com");
        System.out.println(inet02);

        // 获得主机名
        String hostName = inet01.getHostName();
        System.out.println(hostName);
        // 获得IP地址字符串
        String hostAddress = inet01.getHostAddress();
        System.out.println(hostName);
        System.out.println(hostAddress);
    }
}

第二章 UDP通信程序

2.1 UDP协议概述

? UDP是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。

? 由于使用UDP协议消耗资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输例如视频会议都使用UDP协议，因为这种情况即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。

? 但是在使用UDP协议传送数据时，由于UDP的面向无连接性，不能保证数据的完整性，因此在传输重要数据时不建议使用UDP协议。

? UDP通信过程如下图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-clasrf1K-1635077258765)(img/05_UDP通信过程.png)]

UDP协议的特点
    * 面向无连接的协议
    * 发送端只管发送，不确认对方是否能收到。
    * 基于数据包进行数据传输。
    * 发送数据的大小限制64K以内
    * 因为面向无连接，速度快，但是不可靠。

UDP协议的使用场景
    * 即时通讯
    * 在线视频
    * 网络语音电话

UDP协议相关的两个类
    * DatagramPacket
        * 数据包对象
        * 作用：用来封装要发送或要接收的数据，比如：集装箱
    * DatagramSocket
        * 发送对象
        * 作用：用来发送或接收数据包，比如：码头

DatagramPacket类构造方法
    * DatagramPacket(byte[] buf, int length, InetAddress address, int port)
        * 创建发送端数据包对象
        * buf：要发送的内容，字节数组
        * length：要发送内容的长度，单位是字节
        * address：接收端的IP地址对象
        * port：接收端的端口号
    * DatagramPacket(byte[] buf, int length)
        * 创建接收端的数据包对象
        * buf：用来存储接收到内容
        * length：能够接收内容的长度

DatagramPacket类常用方法
    * int getLength() 获得实际接收到的字节个数

DatagramSocket类构造方法
    * DatagramSocket() 创建发送端的Socket对象，系统会随机分配一个端口号。
    * DatagramSocket(int port) 创建接收端的Socket对象并指定端口号

DatagramSocket类成员方法
    * void send(DatagramPacket dp) 发送数据包
    * void receive(DatagramPacket p) 接收数据包

2.2 UDP通信案例

• 需求：教师的电脑的一个程序发送数据，一个程序接收数据，使用的教师本机的ip。

2.2.1 UDP发送端代码实现

// UDP发送端代码实现
public class UDPSender {
    public static void main(String[] args)throws Exception{
        // 定义一个字符串：要发送的内容
        String message = "约吗";
        // 字符串转字节数组
        byte[] buf = message.getBytes();
        // 创建数据包对象
        DatagramPacket dp = new DatagramPacket(buf,buf.length,
                InetAddress.getLocalHost(),6666);
        // 创建发送端的发送对象
        DatagramSocket ds = new DatagramSocket(8888);
        // 发送数据包
        ds.send(dp);
        // 关闭发送对象释放端口号
        ds.close();
    }
}

2.2.2 UDP接收端代码实现

/**
    UDP协议接收端代码实现
 */
public class UDPReceive {
    public static void main(String[] args)throws Exception{
        // 创建接收对象DatagramSocket
        DatagramSocket ds = new DatagramSocket(6666);
        // 创建字节数组用来存储接收接收到的内容
        byte[] buf = new byte[1024];
        // 创建数据包对象
        DatagramPacket dp = new DatagramPacket(buf,buf.length);
        // 接收数据包
        ds.receive(dp);

        // 获得实际接收到的字节个数
        int len = dp.getLength();
        System.out.println("len = " + len);
        // 将字节数组的内容转换为字符串输出
        System.out.println(new String(buf,0,len));

        // 获得发送端的ip地址
        String sendIp = dp.getAddress().getHostAddress();
        // 获得发送端的端口号
        int port  = dp.getPort();
        System.out.println(sendIp);
        System.out.println(port);

        // 关闭Socket对象
        ds.close();
    }
}

第三章 TCP通信程序

3.1 TCP协议概述

• TCP协议是面向连接的通信协议，即在传输数据前先在客户端和服务器端建立逻辑连接，然后再传输数据。它提供了两台计算机之间可靠无差错的数据传输。
• TCP通信过程如下图所示：

TCP ==> Transfer Control Protocol ==> 传输控制协议
TCP协议的特点
    * 面向连接的协议
    * 只能由客户端主动发送数据给服务器端，服务器端接收到数据之后，可以给客户端响应数据。
    * 通过三次握手建立连接，连接成功形成数据传输通道。
    * 通过四次挥手断开连接
    * 基于IO流进行数据传输
    * 传输数据大小没有限制
    * 因为面向连接的协议，速度慢，但是是可靠的协议。

TCP协议的使用场景
    * 文件上传和下载
    * 邮件发送和接收
    * 远程登录

TCP协议相关的类
    * Socket
        * 一个该类的对象就代表一个客户端程序。
    * ServerSocket
        * 一个该类的对象就代表一个服务器端程序。

Socket类构造方法
    * Socket(String host, int port)
        * 根据ip地址字符串和端口号创建客户端Socket对象
        * 注意事项：只要执行该方法，就会立即连接指定的服务器程序，如果连接不成功，则会抛出异常。
            如果连接成功，则表示三次握手通过。

Socket类常用方法
    * OutputStream getOutputStream(); 获得字节输出流对象
    * InputStream getInputStream();获得字节输入流对象

3.2 TCP通信案例

3.2.1 客户端向服务器发送数据

/*
TCP客户端代码实现步骤
        * 创建客户端Socket对象并指定服务器地址和端口号
        * 调用Socket对象的getOutputStream方法获得字节输出流对象
        * 调用字节输出流对象的write方法往服务器端输出数据
        * 调用Socket对象的getInputStream方法获得字节输入流对象
        * 调用字节输入流对象的read方法读取服务器端返回的数据
        * 关闭Socket对象断开连接。
 */
// TCP客户端代码实现
public class TCPClient {
    public static void main(String[] args) throws Exception{
        // 要发送的内容
        String content = "你好TCP服务器端，约吗";
        // 创建Socket对象
        Socket socket = new Socket("192.168.73.99",9999);
        // System.out.println(socket);
        // 获得字节输出流对象
        OutputStream out = socket.getOutputStream();
        // 输出数据到服务器端
        out.write(content.getBytes());

        // 获得字节输入流对象
        InputStream in = socket.getInputStream();
        // 创建字节数组：用来存储读取到服务器端数据
        byte[] buf = new byte[1024];
        // 读取服务器端返回的数据
        int len = in.read(buf);
        System.out.println("len = " + len);
        System.out.println("服务器端返回的内容 = " + new String(buf,0,len));

        // 关闭socket对象
        socket.close();
    }
}

3.2.2 服务器向客户端回写数据

/**
    TCP服务器端代码实现

    ServerSocket类构造方法
        * ServerSocket(int port) 根据指定的端口号开启服务器。

    ServerSocket类常用方法
        *  Socket accept() 等待客户端连接并获得与客户端关联的Socket对象

    TCP服务器端代码实现步骤
        * 创建ServerSocket对象并指定端口号(相当于开启了一个服务器)
        * 调用ServerSocket对象的accept方法等待客端户连接并获得对应Socket对象
        * 调用Socket对象的getInputStream方法获得字节输入流对象
        * 调用字节输入流对象的read方法读取客户端发送的数据
        * 调用Socket对象的getOutputStream方法获得字节输出流对象
        * 调用字节输出流对象的write方法往客户端输出数据
        * 关闭Socket和ServerSocket对象
 */
public class TCPServer {
    public static void main(String[] args)throws Exception{
        // 创建服务器ocket对象
        ServerSocket serverSocket = new ServerSocket(9999);
        // 等待客户端连接并获得与客户端关联的Socket对象
        Socket socket = serverSocket.accept();
        // 获得字节输入流对象
        InputStream in = socket.getInputStream();
        // 创建字节数组：用来存储读取到客户端发送的数据
        byte[] buf = new byte[1024];
        // 读取客户端发送过来的数据
        int len = in.read(buf);
        System.out.println("len = " + len);
        System.out.println("客户端发送的数据 = " + new String(buf,0,len));

        // 获得字节输出流对象
        OutputStream out = socket.getOutputStream();
        // 往客户端输出数据
        out.write("约你妹".getBytes());
       
        
        // 关闭socket
        socket.close();
        // 关闭服务器（在实际开发中，服务器一般不会关闭）
        serverSocket.close();
    }
}

第四章 综合案例

4.1 文件上传案例

文件上传分析图解

1. 【客户端】输入流，从硬盘读取文件数据到程序中。

2. 【客户端】输出流，写出文件数据到服务端。

3. 【服务端】输入流，读取文件数据到服务端程序。

4. 【服务端】输出流，写出文件数据到服务器硬盘中。

5. 【服务端】获取输出流，回写数据。

6. 【客户端】获取输入流，解析回写数据。

案例实现

服务器端实现：

public class FileUpload_Server {
    public static void main(String[] args) throws IOException {
        System.out.println("服务器 启动.....  ");
        // 1. 创建服务端ServerSocket
        ServerSocket serverSocket = new ServerSocket(6666);
        // 2. 循环接收,建立连接
        while (true) {
            Socket accept = serverSocket.accept();
          	/*
          	3. socket对象交给子线程处理,进行读写操作
               Runnable接口中,只有一个run方法,使用lambda表达式简化格式
            */
            new Thread(() -> {
                try (
                    //3.1 获取输入流对象
                    BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
                    //3.2 创建输出流对象, 保存到本地 .
                    FileOutputStream fis = new FileOutputStream(System.currentTimeMillis() + ".jpg");
                    BufferedOutputStream bos = new BufferedOutputStream(fis);
                ) {
                    // 3.3 读写数据
                    byte[] b = new byte[1024 * 8];
                    int len;
                    while ((len = bis.read(b)) != -1) {
                        bos.write(b, 0, len);
                    }

                    // 4.=======信息回写===========================
                    System.out.println("back ........");
                    OutputStream out = accept.getOutputStream();
                    out.write("上传成功".getBytes());
                    out.close();
                    //================================

                    //5. 关闭 资源
                    bos.close();
                    bis.close();
                    accept.close();
                    System.out.println("文件上传已保存");
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

客户端实现：

public class FileUpload_Client {
    public static void main(String[] args) throws IOException {
        // 1.创建流对象
        // 1.1 创建输入流,读取本地文件
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("test.jpg"));
        // 1.2 创建输出流,写到服务端
        Socket socket = new Socket("localhost", 6666);
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());

        //2.写出数据.
        byte[] b  = new byte[1024 * 8];
        int len ;
        while (( len  = bis.read(b))!=-1) {
            bos.write(b, 0, len);
        }
      	// 关闭输出流,通知服务端,写出数据完毕
        socket.shutdownOutput();
        System.out.println("文件发送完毕");
        // 3. =====解析回写============
        InputStream in = socket.getInputStream();
        byte[] back = new byte[20];
        in.read(back);
        System.out.println(new String(back));
        in.close();
        // ============================

        // 4.释放资源
        socket.close();
        bis.close();
    }
}

4.2 模拟B\S服务器

模拟网站服务器，使用浏览器访问自己编写的服务端程序，查看网页效果。

案例分析

1. 准备页面数据，web文件夹。
2. 我们模拟服务器端，ServerSocket类监听端口，使用浏览器访问，查看网页效果

案例实现

浏览器工作原理是遇到图片会开启一个线程进行单独的访问,因此在服务器端加入线程技术。

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        ServerSocket server = new ServerSocket(8888);
        while(true){
            Socket socket = server.accept();
            new Thread(new Web(socket)).start();
        }
    }
}  

class Web implements Runnable{
    private Socket socket;

    public Web(Socket socket){
        this.socket=socket;
    }

    public void run() {
        try{
            //转换流,读取浏览器请求第一行
            BufferedReader readWb = new
                    BufferedReader(new InputStreamReader(socket.getInputStream()));
            String requst = readWb.readLine();
            
            //取出请求资源的路径
            String[] strArr = requst.split(" ");
            System.out.println(Arrays.toString(strArr));
            String path = strArr[1].substring(1);
            System.out.println(path);

            FileInputStream fis = new FileInputStream(path);
            System.out.println(fis);
            byte[] bytes= new byte[1024];
            int len = 0 ;

            //向浏览器 回写数据
            OutputStream out = socket.getOutputStream();
            out.write("HTTP/1.1 200 OK\r\n".getBytes());
            out.write("Content-Type:text/html\r\n".getBytes());
            out.write("\r\n".getBytes());
            while((len = fis.read(bytes))!=-1){
                out.write(bytes,0,len);
            }
            fis.close();
            out.close();
            readWb.close();
            socket.close();
        }catch(Exception ex){

        }
    }
}

第五章 NIO

在我们学习Java的NIO流之前，我们都要了解几个关键词

• 同步与异步（synchronous/asynchronous）：同步是一种可靠的有序运行机制，当我们进行同步操作时，后续的任务是等待当前调用返回，才会进行下一步；而异步则相反，其他任务不需要等待当前调用返回，通常依靠事件、回调等机制来实现任务间次序关系。
• 阻塞与非阻塞：在进行阻塞操作时，当前线程会处于阻塞状态，无法从事其他任务，只有当条件就绪才能继续，比如ServerSocket新连接建立完毕，或者数据读取、写入操作完成；而非阻塞则是不管IO操作是否结束，直接返回，相应操作在后台继续处理

5.1 I/O模型

概念：I/O模型简单的理解，就是用什么样的通道进行数据的发送和接收，很大程度上决定了程序通信的性能。

5.1.1 Java支持3种网络编程模型/IO模式

1)、Java BIO：同步并阻塞（传统阻塞型），服务器实现模式为一个连接一个线程，即客户端有连接请求时，服务器就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销

2)、Java NIO：同步非阻塞，服务器实现模式为一个线程处理多个请求（连接），即客户端发送的连接请求都会注册到多路复用器（Selector选择器）上，多路复用器轮询到连接有I/O请求就进行处理。

3)、Java AIO（NIO.2）：异步非阻塞，AIO引入异步通道的概念，采用了Proactor模式，简化了程序编写，有效的请求才启动线程，它的特点是先由操作系统完成后才通知服务端程序启动线程去处理，一般适用于连接数较多且连接时间较长的应用。JDK1.7才出现，尚未广泛应用。

5.1.2 适用场景分析

1）、BIO方式适用于连接数目比较小且固定的架构，BIO这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，虽然BIO方式不适合处理过多的高并发，但程序简单易理解。

2）、NIO方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器、弹幕系统、服务器间通讯等。编程比较复杂，JDK1.4开始支持。

3）、AIO方式适用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用OS（操作系统）参与并发操作。编程比较复杂，JDK1.7开始支持。

5.2 Java BIO概述

5.2.1 Java BIO基本介绍

1）、Java BIO 就是传统的java io编程，其相关的类和接口在java.io包下。

2）、BIO（Blocking I/O）:同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善，这个线程池机制主要是实现多客户端连接服务器，但并不能减少线程的个数，即使使用线程池，仍然会存在大量任务阻塞在队列的情况。

3）、BIO方式适用于连接数目比较小且固定的架构，BIO这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，虽然BIO方式不适合处理过多的高并发，但程序简单易理解。

5.2.2 Java BIO编程流程

1）、服务器端启动ServerSocket

2）、客户端启动Socket对服务器进行通信，默认情况下服务器端需要对每个客户端建立一个线程与之通信

3）、客户端发出请求后，先咨询服务器是否有线程响应，如果没有则会等待，或者被拒绝

4）、若服务器有响应，客户端线程会等待请求结束后，再继续执行

5.2.3 Java BIO应用实例

需求：

1）、使用BIO模型编写一个服务器端，监听6666端口，当有客户端连接时，就启动一个线程与之通信。

2）、要求使用线程池机制改善，可以连接多个客户端。

3）、服务器端可以接收客户端发送的数据（也可使用telnet方式，则无需再编写客户端）

//1.什么是Telnet？
　　对于Telnet的认识，不同的人持有不同的观点，可以把Telnet当成一种通信协议，但是对于入侵者而言，Telnet只是一种远程登录的工具。一旦入侵者与远程主机建立了Telnet连接，入侵者便可以使用目标主机上的软、硬件资源，而入侵者的本地机只相当于一个只有键盘和显示器的终端而已。
    Telnet协议是TCP/IP协议家族中的一员，是Internet远程登陆服务的标准协议和主要方式。它为用户提供了在本地计算机上完成远程主机工作的能力。在终端使用者的电脑上使用telnet程序，用它连接到服务器。终端使用者可以在telnet程序中输入命令，这些命令会在服务器上运行，就像直接在服务器的控制台上输入一样。可以在本地就能控制服务器。要开始一个telnet会话，必须输入用户名和密码来登录服务器。Telnet是常用的远程控制Web服务器的方法。

//2.怎么执行telnet 命令？
　　1、点击开始　→　运行　→　输入CMD，回车。
　　2、在出来的DOS界面里，输入telnet测试端口命令： telnet IP 端口 或者 telnet 域名 端口，回车。
　　如果端口关闭或者无法连接，则显示不能打开到主机的链接，链接失败；端口打开的情况下，链接成功，则进入telnet页面（全黑的），证明端口可用。

//3.Telnet 客户端命常用命令？
　　open : 使用 openhostname 可以建立到主机的 Telnet 连接。

　　close : 使用命令 close 命令可以关闭现有的 Telnet 连接。

　　display : 使用 display 命令可以查看 Telnet 客户端的当前设置。

　　send : 使用 send 命令可以向 Telnet 服务器发送命令。
      
//windows系统修改cmd窗口utf-8编码格式  直接输入“chcp 65001”，回车键（Enter键）执行，这时候该窗口编码已经是UTF-8编码了。

5.2.4 Java BIO问题分析

1）、每个请求（即客户端）都需要创建独立的线程，与对应的客户端进行数据 Read，业务处理，数据 Write 。

2）、当并发数较大时，需要创建大量线程来处理连接，系统资源占用较大。

3）、连接建立后，如果当前线程暂时没有数据可读，则线程就阻塞在 Read 操作上，造成线程资源浪费

5.3 Java NIO概述

5.3.1 Java NIO 基本介绍

1）、Java NIO 全称 java non-blocking IO，是指 JDK 提供的新 API。从 JDK1.4 开始，Java 提供了一系列改进的输入/输出的新特性，被统称为 NIO(即 New IO)，是同步非阻塞的。

2）、NIO 相关类都被放在 java.nio 包及子包下，并且对原 java.io 包中的很多类进行改写。

3）、NIO 有三大核心部分：Channel(通道)，Buffer(缓冲区), Selector(选择器)

4）、NIO是 面向缓冲区 ，或者面向块编程的。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动，这就增加了处理过程中的灵活性，使用它可以提供非阻塞式的高伸缩性网络。

5）、Java NIO的非阻塞模式，使一个线程从某通道发送请求或者读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。 非阻塞写也是如此，一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。

6）、通俗理解：NIO是可以做到用一个线程来处理多个操作的。假设有10000个请求过来,根据实际情况，可以分配50或者100个线程来处理。不像之前的阻塞IO那样，非得分配10000个。

7）、HTTP2.0使用了多路复用的技术，做到同一个连接并发处理多个请求，而且并发请求的数量比HTTP1.1大了好几个数量级。

5.3.2 NIO 和 BIO 的比较

1）、BIO 以流的方式处理数据,而 NIO 以块的方式处理数据,块 I/O 的效率比流 I/O 高很多

2）、BIO 是阻塞的，NIO 则是非阻塞的

3）、BIO基于字节流和字符流进行操作，而 NIO 基于 Channel(通道)和 Buffer(缓冲区)进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector(选择器)用于监听多个通道的事件（比如：连接请求，数据到达等），因此使用单个线程就可以监听多个客户端通道 。

5.3.3 NIO 三大核心原理示意图

一张图描述NIO 的 Selector 、 Channel 和 Buffer 的关系

Selector 、 Channel 和 Buffer 的关系图(简单版)
关系图的说明:
1）、每个channel 都会对应一个Buffer

2）、Selector 对应一个线程， 一个线程对应多个channel(连接)

3）、该图反应了有三个channel 注册到 该selector

4）、程序切换到哪个channel 是有事件决定的, Event 就是一个重要的概念

5）、Selector 会根据不同的事件，在各个通道上切换

6）、Buffer 就是一个内存块 ， 底层是有一个数组

7）、数据的读取写入是通过Buffer, 这个和BIO , BIO 中要么是输入流，或者是输出流, 不能双向，但是NIO的Buffer 是可以读也可以写, 需要 flip 方法切换

8）、channel 是双向的, 可以返回底层操作系统的情况, 比如Linux ， 底层的操作系统通道就是双向的.

5.3.4 Buffer缓冲区

? 缓冲区（Buffer）：缓冲区本质上是一个可以读写数据的内存块，可以理解成是一个容器对象(含数组)，该对象提供了一组方法，可以更轻松地使用内存块，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况。Channel 提供从文件、网络读取数据的渠道，但是读取或写入的数据都必须经由 Buffer。

如图:

5.3.4.1 Buffer 类及其子类

1. 在 NIO 中，Buffer 是一个顶层父类，它是一个抽象类, 类的层级关系图:

常用Buffer子类一览

ByteBuffer，存储字节数据到缓冲区
ShortBuffer，存储字符串数据到缓冲区
CharBuffer，存储字符数据到缓冲区
IntBuffer，存储整数数据到缓冲区
LongBuffer，存储长整型数据到缓冲区
DoubleBuffer，存储小数到缓冲区
FloatBuffer，存储小数到缓冲区

2. Buffer类定义了所有的缓冲区都具有的四个属性来提供关于其所包含的数据元素的信息:

// Invariants: mark <= position <= limit <= capacity
private int mark = -1;
private int position = 0;
private int limit;
private int capacity;

3. Buffer类相关方法一览

public abstract class Buffer {
    //JDK1.4时，引入的api
    public final int capacity( )//返回此缓冲区的容量
    public final int position( )//返回此缓冲区的位置
    public final Buffer position (int newPositio)//设置此缓冲区的位置
    public final int limit( )//返回此缓冲区的限制
    public final Buffer limit (int newLimit)//设置此缓冲区的限制
    public final Buffer mark( )//在此缓冲区的位置设置标记
    public final Buffer reset( )//将此缓冲区的位置重置为以前标记的位置
    public final Buffer clear( )//清除此缓冲区, 即将各个标记恢复到初始状态，但是数据并没有真正擦除, 后面操作会覆盖
    public final Buffer flip( )//反转此缓冲区
    public final Buffer rewind( )//重绕此缓冲区
    public final int remaining( )//返回当前位置与限制之间的元素数
    public final boolean hasRemaining( )//告知在当前位置和限制之间是否有元素
    public abstract boolean isReadOnly( );//告知此缓冲区是否为只读缓冲区
 
    //JDK1.6时引入的api
    public abstract boolean hasArray();//告知此缓冲区是否具有可访问的底层实现数组
    public abstract Object array();//返回此缓冲区的底层实现数组
    public abstract int arrayOffset();//返回此缓冲区的底层实现数组中第一个缓冲区元素的偏移量
    public abstract boolean isDirect();//告知此缓冲区是否为直接缓冲区
}

5.3.4.2 ByteBuffer

从前面可以看出对于 Java 中的基本数据类型(boolean除外)，都有一个 Buffer 类型与之相对应，最常用的自然是ByteBuffer 类（二进制数据）

该类的主要方法如下：

public abstract class ByteBuffer {
    //缓冲区创建相关api
    public static ByteBuffer allocateDirect(int capacity)//创建直接缓冲区
    public static ByteBuffer allocate(int capacity)//设置缓冲区的初始容量
    public static ByteBuffer wrap(byte[] array)//把一个数组放到缓冲区中使用
    //构造初始化位置offset和上界length的缓冲区
    public static ByteBuffer wrap(byte[] array,int offset, int length)
     //缓存区存取相关API
    public abstract byte get( );//从当前位置position上get，get之后，position会自动+1
    public abstract byte get (int index);//从绝对位置get
    public abstract ByteBuffer put (byte b);//从当前位置上添加，put之后，position会自动+1
    public abstract ByteBuffer put (int index, byte b);//从绝对位置上put
 }

5.3.5 Channel 通道

5.3.5.1 基本介绍

1）、NIO的通道类似于流，但有些区别如下：

通道可以同时进行读写，而流只能读或者只能写

通道可以实现异步读写数据

通道可以从缓冲读数据，也可以写数据到缓冲:

2）、BIO 中的 stream 是单向的，例如 FileInputStream 对象只能进行读取数据的操作，而 NIO 中的通道(Channel)是双向的，可以读操作，也可以写操作。

3）、Channel在NIO中是一个接口public interface Channel extends Closeable{}

4）、常用的 Channel 类有：FileChannel、DatagramChannel、ServerSocketChannel 和 SocketChannel。【ServerSocketChanne 类似 ServerSocket , SocketChannel 类似 Socket】

5）、FileChannel 用于文件的数据读写，DatagramChannel 用于 UDP 的数据读写，ServerSocketChannel 和 SocketChannel 用于 TCP 的数据读写。

5.3.5.2 FileChannel 类

FileChannel主要用来对本地文件进行 IO 操作，常见的方法有

public int read(ByteBuffer dst) ，从通道读取数据并放到缓冲区中

public int write(ByteBuffer src) ，把缓冲区的数据写到通道中

public long transferFrom(ReadableByteChannel src, long position, long count)，从目标通道中复制数据到当前通道

public long transferTo(long position, long count, WritableByteChannel target)，把数据从当前通道复制给目标通道

5.3.5.3 案例

需求1：本地文件写数据，使用前面学习后的ByteBuffer(缓冲) 和 FileChannel(通道)， 将 “hello world” 写入到abc.txt 中，若文件不存在就创建。

需求2：本地文件读数据，使用前面学习后的ByteBuffer(缓冲) 和 FileChannel(通道)， 将 abc.txt 中的数据读入到程序，并显示在控制台屏幕，假定文件已经存在。

需求3：使用一个Buffer完成文件读取，使用 FileChannel(通道) 和 方法 read , write，完成文件的拷贝，拷贝一个文本文件abc.txt , 放在项目下即可。

需求4：拷贝文件transferFrom 方法，使用 FileChannel(通道) 和 方法 transferFrom ，完成文件的拷贝，拷贝一张图片。

5.3.5.4 关于Buffer 和 Channel的注意事项和细节

1）、ByteBuffer 支持类型化的put 和 get, put 放入的是什么数据类型，get就应该使用相应的数据类型来取出，否则可能有 BufferUnderflowException 异常。

import java.nio.ByteBuffer;

public class NioByteBufferPutGet {
    public static void main(String[] args) {
        ByteBuffer byteBuffer= ByteBuffer.allocate(64);
        byteBuffer.putInt(123);
        byteBuffer.putLong(23444444);
        byteBuffer.putChar('大');
        byteBuffer.putShort((short)20);

        byteBuffer.flip();
        System.out.println();
        System.out.println(byteBuffer.getInt());
        System.out.println(byteBuffer.getLong());
        System.out.println(byteBuffer.getChar());// 改成 getInt() 就会抛出异常
        System.out.println(byteBuffer.getShort());


    }
}

2）、可以将一个普通Buffer 转成只读Buffer

import java.nio.ByteBuffer;

/**
 * 只读buffer，顾名思义只能用来读，很有用的，让别人不能修改，只能读
 * 只读buffer底层是：HeapByteBufferR，而普通buffer底层是：HeapByteBuffer
 * 如果向里面put数据会抛出异常，看源码会发现，他的put方法就是直接抛异常。
 * 可以debug 一下
 */
public class ReadOnlyBuffer {
    public static void main(String[] args) {

        ByteBuffer byteBuffer = ByteBuffer.allocate(10);

        for (int i=0;i<10;i++){
            byteBuffer.put((byte) i);
        }

        byteBuffer.flip();

        ByteBuffer onlyReadBuffer=byteBuffer.asReadOnlyBuffer();
        System.out.println(onlyReadBuffer.getClass());
        while (onlyReadBuffer.hasRemaining()){
            System.out.println(onlyReadBuffer.get());
        }
        onlyReadBuffer.put((byte) 10);// ReadOnlyBufferException打开这句，就会抛出异常
    }
}

3）、NIO 还提供了 MappedByteBuffer， 可以让文件直接在内存（堆外的内存）中进行修改， 而如何同步到文件由NIO 来完成.

import java.io.FileNotFoundException;
import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

/**
 * MappedByteBuffer作用：可以让文件直接在内存（堆外的内存）中进行修改，而操作系统不需要拷贝一次，有点像DirectByteBuffer
 * 实际上DirectByteBuffer也是MappedByteBuffer作用的子类。
 *
 * 注意：执行完代码后，IDEA的文件并没有及时改变，但是如果我们在外面打开文件，他的确是发生改变的。
 * //右键 show in ex... 在打开文件即可
 */
public class MappedByteBufferTest {
    public static void main(String[] args) throws Exception {

        RandomAccessFile randomAccess = new RandomAccessFile("1.txt", "rw");
        FileChannel fileChannel = randomAccess.getChannel();
        //0-4范围内容可以直接在内存操作 [即五个字节位置]
        /**
         * 第一个参数是 模式， 我们使用的读写模式
         * 第2个参数是  是起始位置
         * 第3个参数是  是映射到内存的大小
         */
        MappedByteBuffer mappedByteBuffer = fileChannel.map(FileChannel.MapMode.READ_WRITE, 0, 5);

        //这里我们就直接在内存操作，就可以修改文件
        mappedByteBuffer.put(0, (byte) 'o');//修改第一个位置
        mappedByteBuffer.put(1, (byte) 'p');//修改第2个位置
        //修改第11个位置, 抛出 IndexOutOfBoundsException，需要将 0,5 改成 0,11 而不是 0,10
        //mappedByteBuffer.put(10, (byte) 'x');
        randomAccess.close();
    }
}

4）、前面我们讲的读写操作，都是通过一个Buffer 完成的，NIO 还支持 通过多个Buffer (即 Buffer 数组) 完成读写操作，即 Scattering 分散和 Gathering 聚合

实例要求:
使用 FileChannel(通道) 和 方法 transferFrom ，完成文件的拷贝

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Arrays;

/**
 * Scattering:在将数据写入到buffer中时，可以采用buffer数组，依次写入，一个buffer满了就写下一个。
 * Gatering：在将数据读出到buffer中时，可以采用buffer数组，依次读入，一个buffer满了就读下一个。
 */

/**
 * 使用方式：打开cmd telnet locakhost 8899， 测试一次，就重新启动连接一次 [不足8个，刚刚8个字符，超过8个]
 * 连接后可以输入字符串了
 */

public class ScatteringAndGatherIngTest {
    public static void main(String[] args) throws IOException {

        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        InetSocketAddress address = new InetSocketAddress(7000);
        serverSocketChannel.socket().bind(address); //绑定将端口绑定到 scoket ，并启动监听

        int messageLength = 5 + 3;

        ByteBuffer[] byteBuffers = new ByteBuffer[2];
        byteBuffers[0] = ByteBuffer.allocate(5);
        byteBuffers[1] = ByteBuffer.allocate(3);


        SocketChannel socketChannel = serverSocketChannel.accept();
        while (true) {
            int byteRead = 0;
            //接受客户端写入的的字符串
            while (byteRead < messageLength) {
                long r = socketChannel.read(byteBuffers);
                byteRead += r;
                System.out.println("byteRead:" + byteRead);
                //通过流打印
                Arrays.asList(byteBuffers).stream().map(buffer -> "postiton:" +       buffer.position() + ",limit:" + buffer.limit()).forEach(System.out::println);
            }
            
            //将所有buffer都flip。
            Arrays.asList(byteBuffers).forEach(buffer -> {buffer.flip();});
            
            //将数据读出回显到客户端
            long byteWrite = 0;
            while (byteWrite < messageLength) {
                long r = socketChannel.write(byteBuffers);
                byteWrite += r;
            }
            //将所有buffer都clear
            Arrays.asList(byteBuffers).forEach(buffer -> {buffer.clear();});

            System.out.println("byteRead:" + byteRead + ",byteWrite:" + byteWrite + ",messageLength:" + messageLength);
        }
    }
}

5.3.6 Selector 选择器

5.3.6.1 基本介绍

1）、Java 的 NIO，用非阻塞的 IO 方式。可以用一个线程，处理多个的客户端连接，就会使用到Selector(选择器)。

2）、Selector 能够检测多个注册的通道上是否有事件发生(注意:多个Channel以事件的方式可以注册到同一个Selector)，如果有事件发生，便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道，也就是管理多个连接和请求。

3）、只有在 连接/通道 真正有读写事件发生时，才会进行读写，就大大地减少了系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程

4）、避免了多线程之间的上下文切换导致的开销

特点再说明:
1）、Netty 的 IO 线程 NioEventLoop 聚合了 Selector(选择器，也叫多路复用器)，可以同时并发处理成百上千个客户端连接。

2）、当线程从某客户端 Socket 通道进行读写数据时，若没有数据可用时，该线程可以进行其他任务。

3）、线程通常将非阻塞 IO 的空闲时间用于在其他通道上执行 IO 操作，所以单独的线程可以管理多个输入和输出通道。

4）、由于读写操作都是非阻塞的，这就可以充分提升 IO 线程的运行效率，避免由于频繁 I/O 阻塞导致的线程挂起。

5）、一个 I/O 线程可以并发处理 N 个客户端连接和读写操作，这从根本上解决了传统同步阻塞 I/O一个连接一个线程模型，架构的性能、弹性伸缩能力和可靠性都得到了极大的提升。

5.3.6.2 Selector类相关方法

Selector 类是一个抽象类, 常用方法和说明如下:

public abstract class Selector implements Closeable { 
	public static Selector open();//得到一个选择器对象
	
    public int select(long timeout);//监控所有注册的通道，当其中有 IO 操作可以进行时，将对应的 SelectionKey 加入到内部集合中并返回，参数用来设置超时时间
	
    public Set<SelectionKey> selectedKeys();//从内部集合中得到所有的 SelectionKey	
}

注意事项:

1）、NIO中的 ServerSocketChannel功能类似ServerSocket，SocketChannel功能类似Socket

2）、selector 相关方法说明
selector.select()//阻塞
selector.select(1000);//阻塞1000毫秒，在1000毫秒后返回
selector.wakeup();//唤醒selector
selector.selectNow();//不阻塞，立马返还

5.3.6.3 NIO 非阻塞 网络编程原理分析图

NIO 非阻塞 网络编程相关的(Selector、SelectionKey、ServerScoketChannel和SocketChannel) 关系梳理图

对图的说明:
1）、当客户端连接时，会通过ServerSocketChannel 得到 SocketChannel

2）、Selector 进行监听 select 方法, 返回有事件发生的通道的个数.

3）、将socketChannel注册到Selector上, register(Selector sel, int ops), 一个selector上可以注册多个SocketChannel

4）、注册后返回一个 SelectionKey, 会和该Selector 关联(集合)

5）、进一步得到各个 SelectionKey (有事件发生)

6）、在通过 SelectionKey 反向获取 SocketChannel , 方法 channel()

7）、可以通过 得到的 channel , 完成业务处理

5.3.6.4 NIO 非阻塞 网络编程快速入门

案例要求:
编写一个 NIO 入门案例，实现服务器端和客户端之间的数据简单通讯（非阻塞）
目的：理解NIO非阻塞网络编程机制

5.3.7 SelectionKey类

1）、SelectionKey，表示 Selector 和网络通道的注册关系, 共四种:

int OP_ACCEPT：有新的网络连接可以 accept，值为 16
int OP_CONNECT：代表连接已经建立，值为 8
int OP_READ：代表读操作，值为 1 
int OP_WRITE：代表写操作，值为 4

//源码中：
public static final int OP_READ = 1 << 0; 
public static final int OP_WRITE = 1 << 2;
public static final int OP_CONNECT = 1 << 3;
public static final int OP_ACCEPT = 1 << 4;

2）、SelectionKey相关方法

public abstract class SelectionKey {
    public abstract Selector selector();//得到与之关联的 Selector 对象
	public abstract SelectableChannel channel();//得到与之关联的通道
	public final Object attachment();//得到与之关联的共享数据
	public abstract SelectionKey interestOps(int ops);//设置或改变监听事件
	public final boolean isAcceptable();//是否可以accept
	public final boolean isReadable();//是否可以读
	public final boolean isWritable();//是否可以写
}

5.3.8 ServerSocketChannel类

1）、ServerSocketChannel 在服务器端监听新的客户端 Socket 连接

2）、相关方法如下

public abstract class ServerSocketChannel extends AbstractSelectableChannel implements NetworkChannel{
    public static ServerSocketChannel open()，得到一个 ServerSocketChannel 通道
    public final ServerSocketChannel bind(SocketAddress local)，设置服务器端端口号
    public final SelectableChannel configureBlocking(boolean block)，设置阻塞或非阻塞模式，取值 false 表示采用非阻塞模式
    public SocketChannel accept()，接受一个连接，返回代表这个连接的通道对象
    public final SelectionKey register(Selector sel, int ops)，注册一个选择器并设置监听事件
}

5.3.9 SocketChannel类

1）、SocketChannel，网络 IO 通道，具体负责进行读写操作。NIO 把缓冲区的数据写入通道，或者把通道里的数据读到缓冲区。

2）、相关方法如下

public abstract class SocketChannel extends AbstractSelectableChannel implements ByteChannel, ScatteringByteChannel, GatheringByteChannel, NetworkChannel{
    public static SocketChannel open();//得到一个 SocketChannel 通道
    public final SelectableChannel configureBlocking(boolean block);//设置阻塞或非阻塞模式，取值 false 表示采用非阻塞模式
    public boolean connect(SocketAddress remote);//连接服务器
    public boolean finishConnect();//如果上面的方法连接失败，接下来就要通过该方法完成连接操作
    public int write(ByteBuffer src);//往通道里写数据
    public int read(ByteBuffer dst);//从通道里读数据
    public final SelectionKey register(Selector sel, int ops, Object att);//注册一个选择器并设置监听事件，最后一个参数可以设置共享数据
    public final void close();//关闭通道
}

5.4 Java AIO 异步不阻塞

1）、JDK 7 引入了 Asynchronous I/O，即 AIO。在进行 I/O 编程中，常用到两种模式：Reactor和 Proactor。Java 的 NIO 就是 Reactor，当有事件触发时，服务器端得到通知，进行相应的处理

2）、AIO 即 NIO2.0，叫做异步不阻塞的 IO。AIO 引入异步通道的概念，采用了 Proactor 模式，简化了程序编写，有效的请求才启动线程，它的特点是先由操作系统完成后才通知服务端程序启动线程去处理，一般适用于连接数较多且连接时间较长的应用

3）、目前 AIO 还没有广泛应用，Netty 也是基于NIO, 而不是AIO， 因此我们就不详解AIO了，有兴趣的同学可以参考 <<Java新一代网络编程模型AIO原理及Linux系统AIO介绍>>

5.5 BIO、NIO、AIO对比表

举例说明
同步阻塞：到理发店理发，就一直等理发师，直到轮到自己理发。
同步非阻塞：到理发店理发，发现前面有其它人理发，给理发师说下，先干其他事情，一会过来看是否轮到自己.
异步非阻塞：给理发师打电话，让理发师上门服务，自己干其它事情，理发师自己来家给你理发

5.6 原生NIO存在的问题

1）、NIO 的类库和 API 繁杂，使用麻烦：需要熟练掌握 Selector、ServerSocketChannel、SocketChannel、ByteBuffer 等。

2）、需要具备其他的额外技能：要熟悉 Java 多线程编程，因为 NIO 编程涉及到 Reactor 模式，你必须对多线程和网络编程非常熟悉，才能编写出高质量的 NIO 程序。

3）、开发工作量和难度都非常大：例如客户端面临断连重连、网络闪断、半包读写、失败缓存、网络拥塞和异常流的处理等等。

4）、JDK NIO 的 Bug：例如臭名昭著的 Epoll Bug，它会导致 Selector 空轮询，最终导致 CPU 100%。直到 JDK 1.7 版本该问题仍旧存在，没有被根本解决。

5.7 Netty框架及优点

1）、Netty 是由 JBOSS 提供的一个 Java 开源框架。Netty 提供异步的、基于事件驱动的网络应用程序框架，用以快速开发高性能、高可靠性的网络 IO 程序。

2）、Netty 可以帮助你快速、简单的开发出一个网络应用，相当于简化和流程化了 NIO 的开发过程

3）、Netty 是目前最流行的 NIO 框架，Netty 在互联网领域、大数据分布式计算领域、游戏行业、通信行业等获得了广泛的应用，知名的 Elasticsearch 、Dubbo 框架内部都采用了 Netty。

Netty的优点

Netty 对 JDK 自带的 NIO 的 API 进行了封装，解决了上述问题。
1）、设计优雅：适用于各种传输类型的统一 API 阻塞和非阻塞 Socket；基于灵活且可扩展的事件模型，可以清晰地分离关注点；高度可定制的线程模型 - 单线程，一个或多个线程池.

2）、使用方便：详细记录的 Javadoc，用户指南和示例；没有其他依赖项，JDK 5（Netty 3.x）或 6（Netty 4.x）就足够了。

3）、高性能、吞吐量更高：延迟更低；减少资源消耗；最小化不必要的内存复制。

4）、安全：完整的 SSL/TLS 和 StartTLS 支持。

5）、社区活跃、不断更新：社区活跃，版本迭代周期短，发现的 Bug 可以被及时修复，同时，更多的新功能会被加入