Netty前置知识

Netty前置知识

IO模型

IO模型就是说用什么样的通道进行数据的发送和接收，Java共支持3种网络编程IO模式：BIO，NIO，AIO

BIO(Blocking IO)

同步阻塞模型，一个客户端连接对应一个处理线程，如下图所示：

服务端示例代码

package com.yelbean.bio;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * BIO(Blocking IO)
 * 同步阻塞模型，一个客户端连接对应一个处理线程
 * SocketServer是服务端
 *
 * 缺点：
 * 1、IO代码里read操作是阻塞操作，如果client只连接，不做数据读写操作或者读写较慢，会导致线程阻塞，浪费资源
 * 2、一个客户端占用一个线程，如果客户端很多，会导致服务器线程太多，压力太大，比如C10K问题，即使采用线程池(500个线程)，也无法支撑该并发量，并且存在线程切换问题
 *
 * 应用场景：BIO方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，但程序简单易理解。
 *
 */
public class SocketServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9000);
        while (true) {
            System.out.println("等待连接。。");
            // 阻塞方法，直到有客户端连接，可用`telnet localhost 9000`命令来模拟客户端发起连接
            Socket clientSocket = serverSocket.accept();
            System.out.println("有客户端连接了。。");

            // 额外开一个线程去做数据读写的处理，因此当一个客户端连接后，该线程则会阻塞在read方法处，而主线程继续往下走，再次阻塞在accept方法处
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        handler(clientSocket);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }

    private static void handler(Socket clientSocket) throws IOException {
        byte[] bytes = new byte[1024];
        System.out.println("准备read。。");
        // 接收客户端的数据，阻塞方法，没有数据可读时就阻塞 (导致线程一直被占用)
        int read = clientSocket.getInputStream().read(bytes);
        System.out.println("read完毕。。");
        if (read != -1) {
            System.out.println("接收到客户端的数据：" + new String(bytes, 0, read));
        }
        clientSocket.getOutputStream().write("HelloClient".getBytes());
        clientSocket.getOutputStream().flush();
    }
}

缺点

1、IO代码里read操作是阻塞操作，如果client只连接，不做数据读写操作或者读写较慢，会导致线程阻塞，浪费资源
2、一个客户端占用一个线程，如果客户端很多，会导致服务器线程太多，压力太大，比如C10K问题，即使采用线程池(500个线程)，也无法支撑该并发量，并且存在线程切换问题

应用场景

BIO方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，但程序简单易理解。

NIO(Non Blocking IO)

同步非阻塞模型，服务器实现模式为一个线程可以处理多个请求(连接)，客户端发送的连接请求都会注册到多路复用器selector上，多路复用器轮询到连接有IO请求就进行处理，JDK1.4开始引入。

初版NIO模型(JDK1.4版本)

通过linux的内核函数select()或poll()来实现，selector不停地轮询遍历所有客户端channel，判断有无读写事件，有的话则进行数据读写处理。实现了用一个线程完成了所有连接和读写操作。

缺点：当客户端连接太多时，会有大量的无效遍历。假如有10000个连接，仅有1000个连接有读写事件，但由于另外的9000个连接未断开，则还是要每次轮询遍历全部的客户端连接(10000个)，有十分之九的遍历是无效的。

服务端示例代码

package com.yelbean.nio;

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.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * 初版NIO模式，JDK1.4版本
 * 通过linux的内核函数select()或poll()来实现，selector不停地轮询遍历所有客户端channel，判断有无读写事件，有的话则进行数据读写处理.
 * 实现了用一个线程完成了所有连接和读写操作。
 * 缺点：当客户端连接太多时，会有大量的无效遍历。假如有10000个连接，仅有1000个连接有读写事件，但由于另外的9000个连接未断开，
 * 则还是要每次轮询遍历全部的客户端连接(10000个)，有十分之九的遍历是无效的。
 */
public class NioServer {
    // 保存客户端连接
    static List<SocketChannel> channelList = new ArrayList<>();

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

        // 创建NIO ServerSocketChannel，与BIO的serverSocket类似，并绑定到9000端口上
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.socket().bind(new InetSocketAddress(9000));
        // 设置ServerSocketChannel为非阻塞，即accept方法不会阻塞
        serverSocketChannel.configureBlocking(false);
        System.out.println("服务启动成功");

        while (true) {
            // 非阻塞模式accept方法不会阻塞，否则会阻塞
            // NIO的非阻塞是由操作系统内部实现的，底层调用了linux内核的accept函数
            SocketChannel socketChannel = serverSocketChannel.accept();

            if (socketChannel != null) { // 如果有客户端进行连接
                System.out.println("客户端连接成功");
                // 设置SocketChannel为非阻塞,即read方法不会阻塞
                socketChannel.configureBlocking(false);
                // 保存客户端连接在List中
                channelList.add(socketChannel);
            }

            // 遍历连接进行数据读取
            Iterator<SocketChannel> iterator = channelList.iterator();
            while (iterator.hasNext()) {
                SocketChannel sc = iterator.next();
                ByteBuffer byteBuffer = ByteBuffer.allocate(128);
                // 非阻塞模式read方法不会阻塞，否则会阻塞
                int len = sc.read(byteBuffer);
                // 如果有数据，把数据打印出来
                if (len > 0) {
                    System.out.println("接收到消息：" + new String(byteBuffer.array()));
                } else if (len == -1) { // 如果客户端断开，把socket从集合中去掉
                    iterator.remove();
                    System.out.println("客户端断开连接");
                }
            }
        }
    }
}

多路复用器版NIO模型(jkd1.5开始引入epoll基于事件响应机制来优化NIO)

过程解析
1）创建ServerSocketChannel，并监听9000端口
2）创建Selector多路复用器
3）将ServerSocketChannel注册到Selector上，并监听OP_ACCEPT事件
4）注册完返回的SelectionKey与channel绑定
5）Selector调用select()方法阻塞等待事件发生
6）客户端连接触发OP_ACCEPT事件，得到一个SocketChannel，用于读写操作
7）SocketChannel注册到Selector上，并监听OP_READ事件
8）客户端向服务端发送数据，触发OP_READ事件

应用场景：

NIO方式适用于连接数目多且连接比较短(轻操作)的架构，比如聊天服务器、弹幕系统、服务器间通讯。