Java NIO，BIO编程 udp和tcp讲解

osi网络七层模型

为使不同计算机厂家的计算机能够互相通信，以便在更大的范围建立计算机网络，有必要建立一个国际范围的网络体系结构标准。具体其组成如下图：

各层的主要功能：
物理层：使原始的数据比特流能在物理介质上传输。
数据链路层：通过校验、确认和反馈重发等手段，形成稳定的数据链路。
网络层：进行路由选择和流量控制。（IP协议）
传输层：提供可靠的端口到端口的数据传输服务（TCP/UDP协议）。
会话层：负责建立，管理和终止进程之间的会话和数据交换。
表示层：负责数据格式转换、数据加密与解密、压缩和解压缩等。
应用层：为用户的应用进程提供网络服务。

传输控制协议TCP
传输控制协议TCP是internet是一个重要的传输协议。TCP提供面向连接( 网络处理之前先建立连接)、可靠、有序、字节流传输服务。应用程序在使用TCP之前，必须建立TCP连接。(http基于高三层 http基于tcp协议)其下图：数据报文数据，上面就是头部。

TCP握手机制：
目的：让数据传输可靠。

**3次握手：**本质不是打通网络在发送数据之前就是检查网络连接是否通畅：可以发送数据seq序号 ack数据包到服务端，1、客户端发送数据报等待确认，2 服务器针对这条消息回复建立连接等待确认（x代表这条数据）3 客户端确认建立连接如： 1.跑过去跟女神说改天去吃饭 2，女神说可以 3，行某一天我们去吃饭
4次挥手： （断开连接）1.客户端说要结束了，2.服务端我已经收到可以等待（客户端等待不能发数据华友数据没处理完）3、处理完后可以关闭了等待确认，4客户端回复可以关闭了
客户端延迟等待最后关闭
1.男：我们分手， 2女：既然你想分手就分手吧 3，女：但是是你要分手的不是我分手的 4，男：那分手吧
用户数据报协议udp
用户数据报协议UDP是Internet传输层协议。
提供无连接、不可靠、数据报尽力传输服务。

udp和tcp的比较：
Tcp：面向连接、提供可靠性保证、慢、资源占用多
UDP:无连接、不可靠、快、资源占用少（只要发送就马上发送出去，tcp不一定因为有3次握手要验证。）
什么时候使用udp：
如视频聊天(能接受丢一些数据没关系)路灯地是否亮状态充分利用快资源占用少。
Socket编程
Internet中应用最广泛的网络应用编程接口，实现与3种底层协议接口：
数据报类型套接字SOCK_DGRAM(面向UDP接口)
流式套接字SOCK_STREAM(面向TCP接口)
原始套接字SOCK_RAW(面向网络层协议接口ip、icmp等)
主要socket API及其调用过程

Socket API函数定义
listen()、accept()函数只用于服务其端（监听端口获取数据）
connect()函数只能用于客户端；
socket()、bind()、send()、recv()、sendto()、recvfrom()、close()、

BIO网络编程：
如下面代码示例：
服务端：

public class BIOServer {

    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(8080);
        System.out.println("服务器启动成功");
        while (!serverSocket.isClosed()) {
            Socket request = serverSocket.accept();// 阻塞没有接收到数据阻塞
            System.out.println("收到新连接 : " + request.toString());
            try {
                // 接收数据、打印
                InputStream inputStream = request.getInputStream(); // net + i/o
                BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
                String msg;
                while ((msg = reader.readLine()) != null) { // 没有数据，阻塞
                    if (msg.length() == 0) {
                        break;
                    }
                    System.out.println(msg);
                }
                System.out.println("收到数据,来自："+ request.toString());
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    request.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        serverSocket.close();
    }
}

客户端：

public class BIOClient {
	private static Charset charset = Charset.forName("UTF-8");

	public static void main(String[] args) throws Exception {
		Socket s = new Socket("localhost", 8080);//连接网络
		OutputStream out = s.getOutputStream();//通过io写数据

		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入：");
		String msg = scanner.nextLine();
		out.write(msg.getBytes(charset)); // 阻塞，写完成
		scanner.close();
		s.close();
	}

}

当启动1服务端和2客户端时会发现服务端只会打印一条收到新连接数据

至于原因是因为上面地服务端io是阻塞地 while ((msg = reader.readLine()) != null) {所以才会只打印一条。当输入一个客户端地时候释放阻塞如：


上面的原因是服务端不能运行多个，是因为是单线程改进方法，服务端设置多线程：

// 多线程支持
public class BIOServer1 {
    private static ExecutorService threadPool = Executors.newCachedThreadPool();

    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(8080);
        System.out.println("tomcat 服务器启动成功");
        while (!serverSocket.isClosed()) {
            Socket request = serverSocket.accept();
            System.out.println("收到新连接 : " + request.toString());
            threadPool.execute(() -> {
                try {
                    // 接收数据、打印
                    InputStream inputStream = request.getInputStream();
                    BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
                    String msg;
                    while ((msg = reader.readLine()) != null) { // 阻塞
                        if (msg.length() == 0) {
                            break;
                        }
                        System.out.println(msg);
                    }
                    System.out.println("收到数据,来自："+ request.toString());
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    try {
                        request.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        serverSocket.close();
    }
}

启动一个服务端和2个客户端运行结果：

http协议-请求数据包解析

http协议-响应数据包解析

http协议-响应状态码
1xx（临时响应）
表示临时响应并需要请求者继续执行操作的状态代码
2xx（成功)
表示成功处理了请求的状态代码。
3xx(重定向)
表示要完成请求，需要进一步操作。通常，这些状态码用来重定向。
4xx(请求错误)
这些状态码表示请求可能出错，妨碍了服务器的处理
5xx（服务器错误）
这些状态码表示服务其在尝试处理请求时发生内部错误。这些错误可能时服务器本身的错误，而不是请求出错。
下面我们在升级服务端可以通过浏览器访问并返回，其主要加上了应用层http协议：

public class BIOServer2 {

    private static ExecutorService threadPool = Executors.newCachedThreadPool();

    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(8080);
        System.out.println("服务器启动成功");
        while (!serverSocket.isClosed()) {
            Socket request = serverSocket.accept();
            System.out.println("收到新连接 : " + request.toString());
            threadPool.execute(() -> {
                try {
                    // 接收数据、打印
                    InputStream inputStream = request.getInputStream();
                    BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, "utf-8"));
                    String msg;
                    while ((msg = reader.readLine()) != null) {
                        if (msg.length() == 0) {
                            break;
                        }
                        System.out.println(msg);
                    }

                    System.out.println("收到数据,来自："+ request.toString());
                    // 响应结果 200 添加http协议
                    OutputStream outputStream = request.getOutputStream();
                    outputStream.write("HTTP/1.1 200 OK\r\n".getBytes());
                    outputStream.write("Content-Length: 11\r\n\r\n".getBytes());
                    outputStream.write("Hello World".getBytes());
                    outputStream.flush();
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    try {
                        request.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        serverSocket.close();
    }
}

没升级的结果：


升级的结果：

BIO-阻塞io的含义
阻塞 io：资源不可用时，io请求一直阻塞，知道反馈结果（有数据或超时）
非阻塞 io:资源不可用时，io请求离开返回，返回数据标识资源不可用。
同步 io：应用阻塞在发送或接受数据的状态，知道数据成功传输或返回失败。
异步io:应用发送或接收数据后立刻返回，实际处理时异步执行的。
阻塞和非阻塞时获取资源的方式，同步/异步时程序如何处理资源的逻辑设计。代码中使用的API:serverSocket#INputStream#read都是阻塞的API。操作系统底层API中，默认Socket操作都是Blocking型，send/recv等接口都是阻塞的。
**带来的问题：**阻塞导致在处理网络i/o时，一个线程只能处理一个网络连接。
NIO网络编程

Java NIO
始于java1.4 提供了新的JAVA IO 操作非阻塞API。用于替代java io和JAVAnetworking相关的api
NIO有3个核心组件：Buffer缓冲区、 Channel通道、 Selector选择器

Buffer缓冲区

缓冲区本质上是一个可以写入数据的内存块(类似数组），然后可以再次读取。此内存块包含在NIO Buffer对象中，该对象提供了一组方法，可以更轻松地使用内存块。
使用Buffer进行数据写入与读取，需要进行如下四个步骤：
1、将数据写入缓冲区
2、调用buffer.flip(),转换为读取模式
3、缓冲区读取数据
4、调用buffer.clear()或buyffer.compact()清除缓冲区

Buffer工作原理

Buffer三个重要属性：
capacity:作为一个内存块，Buffer具有一定的固定大小，也称为“容量。
position位置：写入模式时代表写数据的位置。读取，模式时代表读取数据的位置。
limit限制：写入模式，限制等于buffer的容量。读取模式下，limit等于写入的数据量。

ByteBuffer内存类型

ByteBuffer为性能关键型提供了直接内存(direct堆外）和非直接内存（head堆）两种实现。堆外内存获取的方式：ByteBuffer directByteBuffer=ByteBuffer.allocateDirect(noBytes)
好处：
1、进行网络io或者文件io时比headBuffer少一次拷贝。GC会移动对象内存，再写fie或socket的过程中，JVM的实现中，会先把数据复制到堆外，再进行写入。

2、堆外内存 ：GC范围之外，降低GC压力，但实现了的自动管理。DirectByteBuffer中有一个Cleaner对象
Cleaner会被GC前会执行clean方法，触发DirectByteBuffer中定义的Deadllocator
建议用堆外内存时候：
1、性能确实可观的时候才会去使用；分配给大型、长寿命；（网络传输、文件读写场景）
2、通过虚拟机参数MAxDirectMemorySize限制大小防止耗尽机器的内存；
堆外内存建议上
jvm写入时会多个步骤先是复制堆外内存在复制到jvm中原因是我们jvm在垃圾回收时候会移动内存地址操作系统会写入和读取可能读不到。堆外不受jvm管理，jdk有写
示例代码：

public class BufferDemo {
    public static void main(String[] args) {
        // 构建一个byte字节缓冲区，容量是4
        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(4);
        // 默认写入模式，查看三个重要的指标
        System.out.println(String.format("初始化：capacity容量：%s, position位置：%s, limit限制：%s", byteBuffer.capacity(),
                byteBuffer.position(), byteBuffer.limit()));
        // 写入2字节的数据
        byteBuffer.put((byte) 1);
        byteBuffer.put((byte) 2);
        byteBuffer.put((byte) 3);
        // 再看数据
        System.out.println(String.format("写入3字节后，capacity容量：%s, position位置：%s, limit限制：%s", byteBuffer.capacity(),
                byteBuffer.position(), byteBuffer.limit()));

        // 转换为读取模式(不调用flip方法，也是可以读取数据的，但是 byteBuffer.get()是根据position读取数据的position记录读取的位置不对)
        System.out.println("#######开始读取");
        byteBuffer.flip();
        byte a = byteBuffer.get();
        System.out.println(a);
        byte b = byteBuffer.get();
        System.out.println(b);
        System.out.println(String.format("读取2字节数据后，capacity容量：%s, position位置：%s, limit限制：%s", byteBuffer.capacity(),
                byteBuffer.position(), byteBuffer.limit()));

        // 继续写入3字节，此时读模式下，limit=3，position=2.继续写入只能覆盖写入一条数据
        // clear()方法清除整个缓冲区。compact()方法仅清除已阅读的数据。转为写入模式
        byteBuffer.compact(); // buffer : 1 , 3
        byteBuffer.put((byte) 3);
        byteBuffer.put((byte) 4);
        byteBuffer.put((byte) 5);
        System.out.println(String.format("最终的情况，capacity容量：%s, position位置：%s, limit限制：%s", byteBuffer.capacity(),
                byteBuffer.position(), byteBuffer.limit()));

        // rewind() 重置position为0
        // mark() 标记position的位置
        // reset() 重置position为上次mark()标记的位置

    }
}

Channel通道：
包含了 socket和i/o的api

SocketChannel
SocketChannel用于建立TCP网络连接，类似java.net.Socket。有·两种创建socketChannel形式：
1.客户端主动发起和服务器的连接。
2、服务端获取的新连接。

write写：write(）在尚未写入任何内容时可能返回了。需要在循环中调用write（).
read读：read(）方法可能直接返回而根本不读取任何数据，根据返回的int值判断读取了多少字节。
ServerSocketChannel
ServerSocketChannel可以监听新建的TCP连接通道，类似ServerSocket。

ServerSocketChannel.accept()：如果该通道处于非阻塞模式，那么如果没有挂起的连接，该方法将立即返回null。必须检查返回的SocketChannel是否为null。

示例代码：
客户端代码：

public class NIOClient {

    public static void main(String[] args) throws Exception {
        SocketChannel socketChannel = SocketChannel.open(); 创建网络客户端
        socketChannel.configureBlocking(false); // 设置为非阻塞模式
        socketChannel.connect(new InetSocketAddress("127.0.0.1", 8080));//连接
        while (!socketChannel.finishConnect()) {
            // 没连接上,则一直等待
            Thread.yield();
        }
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入：");
        // 发送内容
        String msg = scanner.nextLine();
        ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
        while (buffer.hasRemaining()) {
            socketChannel.write(buffer);
        }
        // 读取响应
        System.out.println("收到服务端响应:");
        ByteBuffer requestBuffer = ByteBuffer.allocate(1024);

        while (socketChannel.isOpen() && socketChannel.read(requestBuffer) != -1) {
            // 长连接情况下,需要手动判断数据有没有读取结束 (此处做一个简单的判断: 超过0字节就认为请求结束了)
            if (requestBuffer.position() > 0) break;
        }
        requestBuffer.flip();
        byte[] content = new byte[requestBuffer.limit()];
        requestBuffer.get(content);
        System.out.println(new String(content));
        scanner.close();
        socketChannel.close();
    }

}

服务端代码：

**
 * 直接基于非阻塞的写法
 */
public class NIOServer {

    public static void main(String[] args) throws Exception {
        // 创建网络服务端
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false); // 设置为非阻塞模式
        serverSocketChannel.socket().bind(new InetSocketAddress(8080)); // 绑定端口
        System.out.println("启动成功");
        while (true) {
            SocketChannel socketChannel = serverSocketChannel.accept(); // 获取新tcp连接通道
            // tcp请求 读取/响应
            if (socketChannel != null) {
                System.out.println("收到新连接 : " + socketChannel.getRemoteAddress());
                socketChannel.configureBlocking(false); // 默认是阻塞的,一定要设置为非阻塞
                try {
                    ByteBuffer requestBuffer = ByteBuffer.allocate(1024);
                    while (socketChannel.isOpen() && socketChannel.read(requestBuffer) != -1) {
                        // 长连接情况下,需要手动判断数据有没有读取结束 (此处做一个简单的判断: 超过0字节就认为请求结束了)
                        if (requestBuffer.position() > 0) break;
                    }
                    if(requestBuffer.position() == 0) continue; // 如果没数据了, 则不继续后面的处理
                    requestBuffer.flip();
                    byte[] content = new byte[requestBuffer.limit()];
                    requestBuffer.get(content);
                    System.out.println(new String(content));
                    System.out.println("收到数据,来自："+ socketChannel.getRemoteAddress());

                    // 响应结果 200
                    String response = "HTTP/1.1 200 OK\r\n" +
                            "Content-Length: 11\r\n\r\n" +
                            "Hello World";
                    ByteBuffer buffer = ByteBuffer.wrap(response.getBytes());
                    while (buffer.hasRemaining()) {
                        socketChannel.write(buffer);// 非阻塞
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        // 用到了非阻塞的API, 在设计上,和BIO可以有很大的不同.继续改进
    }
}

当我们启动2个客户端和一个服务端时候会发现服务端只打印一个收到连接数据。

这个是因为下面的代码块导致的无限循环建立连接时候第一个进入无数据传送导致循环。

 while (socketChannel.isOpen() && socketChannel.read(requestBuffer) != -1) {
                        // 长连接情况下,需要手动判断数据有没有读取结束 (此处做一个简单的判断: 超过0字节就认为请求结束了)
                        if (requestBuffer.position() > 0) break;
                    }

上面的代码说明服务端还是无法进行多个客户端访问非阻塞的。下面我们在升级其服务端代码如：

/**
 * 直接基于非阻塞的写法,一个线程处理轮询所有请求
 */
public class NIOServer1 {
    /**
     * 已经建立连接的集合
     */
    private static ArrayList<SocketChannel> channels = new ArrayList<>();

    public static void main(String[] args) throws Exception {
        // 创建网络服务端
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false); // 设置为非阻塞模式
        serverSocketChannel.socket().bind(new InetSocketAddress(8080)); // 绑定端口
        System.out.println("启动成功");
        while (true) {
            SocketChannel socketChannel = serverSocketChannel.accept(); // 获取新tcp连接通道
                // tcp请求 读取/响应
                if (socketChannel != null) {
                System.out.println("收到新连接 : " + socketChannel.getRemoteAddress());
                socketChannel.configureBlocking(false); // 默认是阻塞的,一定要设置为非阻塞
                channels.add(socketChannel);
            } else {
                // 没有新连接的情况下,就去处理现有连接的数据,处理完的就删除掉
                Iterator<SocketChannel> iterator = channels.iterator();
                while (iterator.hasNext()) {
                    SocketChannel ch = iterator.next();
                    try {
                        ByteBuffer requestBuffer = ByteBuffer.allocate(1024);

                        if (ch.read(requestBuffer) == 0) {
                            // 等于0,代表这个通道没有数据需要处理,那就待会再处理
                            continue;
                        }
                        while (ch.isOpen() && ch.read(requestBuffer) != -1) {
                            // 长连接情况下,需要手动判断数据有没有读取结束 (此处做一个简单的判断: 超过0字节就认为请求结束了)
                            if (requestBuffer.position() > 0) break;
                        }
                        if(requestBuffer.position() == 0) continue; // 如果没数据了, 则不继续后面的处理
                        requestBuffer.flip();
                        byte[] content = new byte[requestBuffer.limit()];
                        requestBuffer.get(content);
                        System.out.println(new String(content));
                        System.out.println("收到数据,来自：" + ch.getRemoteAddress());

                        // 响应结果 200
                        String response = "HTTP/1.1 200 OK\r\n" +
                                "Content-Length: 11\r\n\r\n" +
                                "Hello World";
                        ByteBuffer buffer = ByteBuffer.wrap(response.getBytes());
                        while (buffer.hasRemaining()) {
                            ch.write(buffer);
                        }
                        iterator.remove();
                    } catch (IOException e) {
                        e.printStackTrace();
                        iterator.remove();
                    }
                }
            }
        }
        // 用到了非阻塞的API, 再设计上,和BIO可以有很大的不同
        // 问题: 轮询通道的方式,低效,浪费CPU
    }
}

在while循环前添加判断了是否有数据这样就不会违背了nio用多线程的话那样右跟io差不多

     if (ch.read(requestBuffer) == 0) {
                            // 等于0,代表这个通道没有数据需要处理,那就待会再处理
                            continue;
                        }

其结果是：

问题：
这种循环检查通道的数据是否建立新连接和是否有数据是低效的。NIO解决这种方式是用Selector选择器。
Selector选择器
Selector是一个JAVA Nio组件，可以检查一个或多个NIO通道，并确定哪些通道已准备好进行读取或写入。实现单个线程可以管理多个通道，从而管理多个网络连接。
一个线程使用Selecttor监听多个channel的不同事件：
四个事件分别对应SelecttionKey四个常量。
1、Connect连接(SelectionKey.op_connect)
2、Accept准备就绪（op_ACCEPT) 服务端
3、read 读取(op_read)
4、Write写入（op_write)

实现一个线程处理多个通道核心概念理解：事件驱动机制。
非阻塞的网络通道下，开发者通过Selector注册对通道感兴趣的事件类型，线程通过监听事件来非阻塞的网络通道下相应代码执行。（扩展：更底层是操作系统的多路服用机制）

代码示例如下：

/**
 * 结合Selector实现的非阻塞服务端(放弃对channel的轮询,借助消息通知机制)
 */
public class NIOServerV2 {

    public static void main(String[] args) throws Exception {
        // 1. 创建网络服务端ServerSocketChannel
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false); // 设置为非阻塞模式

        // 2. 构建一个Selector选择器,并且将channel注册上去
        Selector selector = Selector.open();
        SelectionKey selectionKey = serverSocketChannel.register(selector, 0, serverSocketChannel);// 将serverSocketChannel注册到selector
        selectionKey.interestOps(SelectionKey.OP_ACCEPT); // 对serverSocketChannel上面的accept事件感兴趣(serverSocketChannel只能支持accept操作)

        // 3. 绑定端口
        serverSocketChannel.socket().bind(new InetSocketAddress(8080));

        System.out.println("启动成功");

        while (true) {
            // 不再轮询通道,改用下面轮询事件的方式.select方法有阻塞效果,直到有事件通知才会有返回
            selector.select();
            // 获取事件
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            // 遍历查询结果e
            Iterator<SelectionKey> iter = selectionKeys.iterator();
            while (iter.hasNext()) {
                // 被封装的查询结果
                SelectionKey key = iter.next();
                iter.remove();
                // 关注 Read 和 Accept两个事件
                if (key.isAcceptable()) {
                    ServerSocketChannel server = (ServerSocketChannel) key.attachment();
                    // 将拿到的客户端连接通道,注册到selector上面
                    SocketChannel clientSocketChannel = server.accept(); // mainReactor 轮询accept
                    clientSocketChannel.configureBlocking(false);
                    clientSocketChannel.register(selector, SelectionKey.OP_READ, clientSocketChannel);
                    System.out.println("收到新连接 : " + clientSocketChannel.getRemoteAddress());
                }

                if (key.isReadable()) {
                    SocketChannel socketChannel = (SocketChannel) key.attachment();
                    try {
                        ByteBuffer requestBuffer = ByteBuffer.allocate(1024);
                        while (socketChannel.isOpen() && socketChannel.read(requestBuffer) != -1) {
                            // 长连接情况下,需要手动判断数据有没有读取结束 (此处做一个简单的判断: 超过0字节就认为请求结束了)
                            if (requestBuffer.position() > 0) break;
                        }
                        if(requestBuffer.position() == 0) continue; // 如果没数据了, 则不继续后面的处理
                        requestBuffer.flip();
                        byte[] content = new byte[requestBuffer.limit()];
                        requestBuffer.get(content);
                        System.out.println(new String(content));
                        System.out.println("收到数据,来自：" + socketChannel.getRemoteAddress());
                        // TODO 业务操作 数据库 接口调用等等

                        // 响应结果 200
                        String response = "HTTP/1.1 200 OK\r\n" +
                                "Content-Length: 11\r\n\r\n" +
                                "Hello World";
                        ByteBuffer buffer = ByteBuffer.wrap(response.getBytes());
                        while (buffer.hasRemaining()) {
                            socketChannel.write(buffer);
                        }
                    } catch (IOException e) {
                        // e.printStackTrace();
                        key.cancel(); // 取消事件订阅
                    }
                }
            }
            selector.selectNow();
        }
        // 问题: 此处一个selector监听所有事件,一个线程处理所有请求事件. 会成为瓶颈! 要有多线程的运用
    }
}

NIO对比BIO

如果你的程序需要支撑大量的连接，使用NIO是最好的方式。
Tomcat8中，已经完全除去BIO相关的网络处理代码？默认采用NIO进行网络处理。
NIO与多线程结合的改进方案
reactor网络数据接收和处理

代码示例：

/**
 * NIO selector 多路复用reactor线程模型
 */
public class NIOServerV3 {
    /** 处理业务操作的线程 */
    private static ExecutorService workPool = Executors.newCachedThreadPool();

    /**
     * 封装了selector.select()等事件轮询的代码
     */
    abstract class ReactorThread extends Thread {

        Selector selector;
        LinkedBlockingQueue<Runnable> taskQueue = new LinkedBlockingQueue<>();

        /**
         * Selector监听到有事件后,调用这个方法
         */
        public abstract void handler(SelectableChannel channel) throws Exception;

        private ReactorThread() throws IOException {
            selector = Selector.open();
        }

        volatile boolean running = false;

        @Override
        public void run() {
            // 轮询Selector事件
            while (running) {
                try {
                    // 执行队列中的任务
                    Runnable task;
                    while ((task = taskQueue.poll()) != null) {
                        task.run();
                    }
                    selector.select(1000);

                    // 获取查询结果
                    Set<SelectionKey> selected = selector.selectedKeys();
                    // 遍历查询结果
                    Iterator<SelectionKey> iter = selected.iterator();
                    while (iter.hasNext()) {
                        // 被封装的查询结果
                        SelectionKey key = iter.next();
                        iter.remove();
                        int readyOps = key.readyOps();
                        // 关注 Read 和 Accept两个事件
                        if ((readyOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0) {
                            try {
                                SelectableChannel channel = (SelectableChannel) key.attachment();
                                channel.configureBlocking(false);
                                handler(channel);
                                if (!channel.isOpen()) {
                                    key.cancel(); // 如果关闭了,就取消这个KEY的订阅
                                }
                            } catch (Exception ex) {
                                key.cancel(); // 如果有异常,就取消这个KEY的订阅
                            }
                        }
                    }
                    selector.selectNow();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        private SelectionKey register(SelectableChannel channel) throws Exception {
            // 为什么register要以任务提交的形式，让reactor线程去处理？
            // 因为线程在执行channel注册到selector的过程中，会和调用selector.select()方法的线程争用同一把锁
            // 而select()方法实在eventLoop中通过while循环调用的，争抢的可能性很高，为了让register能更快的执行，就放到同一个线程来处理
            FutureTask<SelectionKey> futureTask = new FutureTask<>(() -> channel.register(selector, 0, channel));
            taskQueue.add(futureTask);
            return futureTask.get();
        }

        private void doStart() {
            if (!running) {
                running = true;
                start();
            }
        }
    }

    private ServerSocketChannel serverSocketChannel;
    // 1、创建多个线程 - accept处理reactor线程 (accept线程)
    private ReactorThread[] mainReactorThreads = new ReactorThread[1];
    // 2、创建多个线程 - io处理reactor线程  (I/O线程)
    private ReactorThread[] subReactorThreads = new ReactorThread[8];

    /**
     * 初始化线程组
     */
    private void newGroup() throws IOException {
        // 创建IO线程,负责处理客户端连接以后socketChannel的IO读写
        for (int i = 0; i < subReactorThreads.length; i++) {
            subReactorThreads[i] = new ReactorThread() {
                @Override
                public void handler(SelectableChannel channel) throws IOException {
                    // work线程只负责处理IO处理，不处理accept事件
                    SocketChannel ch = (SocketChannel) channel;
                    ByteBuffer requestBuffer = ByteBuffer.allocate(1024);
                    while (ch.isOpen() && ch.read(requestBuffer) != -1) {
                        // 长连接情况下,需要手动判断数据有没有读取结束 (此处做一个简单的判断: 超过0字节就认为请求结束了)
                        if (requestBuffer.position() > 0) break;
                    }
                    if (requestBuffer.position() == 0) return; // 如果没数据了, 则不继续后面的处理
                    requestBuffer.flip();
                    byte[] content = new byte[requestBuffer.limit()];
                    requestBuffer.get(content);
                    System.out.println(new String(content));
                    System.out.println(Thread.currentThread().getName() + "收到数据,来自：" + ch.getRemoteAddress());

                    // TODO 业务操作 数据库、接口...
                    workPool.submit(() -> {
                    });

                    // 响应结果 200
                    String response = "HTTP/1.1 200 OK\r\n" +
                            "Content-Length: 11\r\n\r\n" +
                            "Hello World";
                    ByteBuffer buffer = ByteBuffer.wrap(response.getBytes());
                    while (buffer.hasRemaining()) {
                        ch.write(buffer);
                    }
                }
            };
        }

        // 创建mainReactor线程, 只负责处理serverSocketChannel
        for (int i = 0; i < mainReactorThreads.length; i++) {
            mainReactorThreads[i] = new ReactorThread() {
                AtomicInteger incr = new AtomicInteger(0);

                @Override
                public void handler(SelectableChannel channel) throws Exception {
                    // 只做请求分发，不做具体的数据读取
                    ServerSocketChannel ch = (ServerSocketChannel) channel;
                    SocketChannel socketChannel = ch.accept();
                    socketChannel.configureBlocking(false);
                    // 收到连接建立的通知之后，分发给I/O线程继续去读取数据
                    int index = incr.getAndIncrement() % subReactorThreads.length;
                    ReactorThread workEventLoop = subReactorThreads[index];
                    workEventLoop.doStart();
                    SelectionKey selectionKey = workEventLoop.register(socketChannel);
                    selectionKey.interestOps(SelectionKey.OP_READ);
                    System.out.println(Thread.currentThread().getName() + "收到新连接 : " + socketChannel.getRemoteAddress());
                }
            };
        }


    }

    /**
     * 初始化channel,并且绑定一个eventLoop线程
     *
     * @throws IOException IO异常
     */
    private void initAndRegister() throws Exception {
        // 1、 创建ServerSocketChannel
        serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);
        // 2、 将serverSocketChannel注册到selector
        int index = new Random().nextInt(mainReactorThreads.length);
        mainReactorThreads[index].doStart();
        SelectionKey selectionKey = mainReactorThreads[index].register(serverSocketChannel);
        selectionKey.interestOps(SelectionKey.OP_ACCEPT);
    }

    /**
     * 绑定端口
     *
     * @throws IOException IO异常
     */
    private void bind() throws IOException {
        //  1、 正式绑定端口，对外服务
        serverSocketChannel.bind(new InetSocketAddress(8080));
        System.out.println("启动完成，端口8080");
    }

    public static void main(String[] args) throws Exception {
        NIOServerV3 nioServerV3 = new NIOServerV3();
        nioServerV3.newGroup(); // 1、 创建main和sub两组线程
        nioServerV3.initAndRegister(); // 2、 创建serverSocketChannel，注册到mainReactor线程上的selector上
        nioServerV3.bind(); // 3、 为serverSocketChannel绑定端口
    }
}

使用webSocket

websocket协议是基于TCP的一种新的网络协议。
它的出现实现了浏览器与服务器全双工(full-duplex)通信：允许服务器主动发送消息给客户端。
多客户端多语言服务器支持：浏览器、php、java、ruby、nginx、python、Tomcat、erlang、.net等。

面试问题：

短连接：请求/响应之后，关闭已经建立的TCP连接，下次请求在建立一次连接。
长连接：请求/响应之后，不关闭TCP连接，多次请求，复用同一个连接。
为了避免频繁创建连接/释放连接嗲来的性能损耗，以及消息获取的实时性，次采用长连接的形式。

粘包：Nagle算法客户端积累一定量或缓冲一段时间再传输。服务端缓冲区堆积。导致多个请求数据粘在一起。
拆包：发送的数据大于发送缓冲区，进行分片传输。服务端缓冲区堆积，导致服务端读取的请求数据不完整。

总结：

NIO为开发者提供了功能丰富及强大的io处理API,但是在应用中直接使用jdk停供的API比较繁琐而且要将性能进行提升关有NIO还不够，还需要将多线程技术与之结合起来。
因为网络编程本身的复杂性。以及jdkapi开发的使用难度较高，所以在开源社区中涌出来很多对jdk nio进行封装、增强后的网络编程框架，例如：Netty、Mina等。
上面的整个工程代码：
https://github.com/fanxishu/java2020peixun/tree/master/subject-1/subject-1-source/chapter-2