【Netty】BIO，NIO，AIO 模型

目录

• 一、输入IO与输出IO原理
• 二、同步和异步的区别
• 三、阻塞与非阻塞的区别
• • 1. BIO客户端
  • 2. BIO服务端
• 四、NIO(Non Blocking IO) 同步非阻塞
• • 1. 简单模拟NIO底层代码实现
  • 2. 选择器IO多路复用底层原理

---

一、输入IO与输出IO原理

内核态: CPU可以访问内存所有数据, 包括外围设备, 例如硬盘, 网卡；

用户态: (独立创建应用程序) 只能受限的访问内存, 且不允许访问外围设备. 占用CPU的能力被剥夺, CPU资源可以被其他程序获

1、BIO(Blocking I O) 同步阻塞模型，一个线程对应一个客户端连接。
应用场景：
BIO 方式适用于连接数目比较小且固定的架构， 这种方式对服务器资源要求比较高， 但程序简单易理解。

2、NIO(Non Blockin g IO) 同步非阻塞，
服务器实现模式为一个线程可以处理多个请求(连接)，客户端发送的连接请求都会注册到 多路复用器selector上，多路复用器轮询到连接有IO请求就进行处理。
应用场景：
NIO方式适用于连接数目多且连接比较短（轻 *** 作） 的架构， 比如聊天服务器， d幕系统， 服务器间通讯，编程比较复杂， JDK1.4 开始支持

3、AIO(NIO 2.0) 异步非阻塞，
由 *** 作系统完成后回调通知服务端程序启动线程去处理， 一般适用于连接数较多且连接时间较长的应用。是在NIO的基础上进一步封装的。
应用场景：
AIO方式适用于连接数目多且连接比较长（重 *** 作） 的架构，JDK7 开始支持

二、同步和异步的区别

同步也就是程序从上往下实现执行；
异步从新开启一个新分支，相互不会影响；

站在Http协议上分析同步与异步区别：

我们的Http协议请求默认情况下同步形式调用，如果调用过程非常耗时的情况下 客户端等待时间就非常长， 这种形式我们可以理解阻塞式；

解决办法：耗时的代码我们可以使用多线程或者MQ实现处理，但是不能立马获取结果； 客户端可以主动查询

三、阻塞与非阻塞的区别

阻塞：如果我没有获取到结果的情况下，当前线程从运行状态切换为阻塞状态 内核角度分析：用户空间切换到内核空间
非阻塞：如果我没有获取到结果的情况下，当前的线程不会阻塞。

BIO(Blocking IO) 同步阻塞模型
一个线程处理一个客户端请求；
缺点：
1、 IO代码里read *** 作是阻塞 *** 作，如果获取不到数据的情况下，则会阻塞；
如果线程使用过多的情况下，非常消耗服务器端cpu的资源；
应用场景：
BIO 方式适用于连接数目比较小且固定的架构， 这种方式对服务器资源要求比较高

1. BIO客户端

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

/***
 * SocketBioClient
 */
public class SocketBioClient {

    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1", 9001);
        //向服务端发送数据
        socket.getOutputStream().write("来演示下同步阻塞Bio".getBytes());
        socket.getOutputStream().flush();
        System.out.println("向服务端发送数据结束");
        byte[] bytes = new byte[1024];
        //接收服务端回传的数据
        socket.getInputStream().read(bytes);
        System.out.println("接收到服务端的数据：" + new String(bytes));
        socket.close();
    }
}

2. BIO服务端

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

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

        ServerSocket serverSocket = new ServerSocket(9001);
        while (true) {
            System.out.println("服务器端正在等待连接中...");
            // 阻塞方法 如果没有客户端与服务器端建立连接时，该方法会阻塞等待
            final Socket socket = serverSocket.accept();
            System.out.println("有客户端和我连接啦");
            //如果不使用异步线程处理接受io *** 作的情况下，有可能会阻塞等待 无法接受新的连接请求。
            new Thread(() -> {
                try {
                    handler(socket);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }).start();
//            handler(socket);
        }
    }

    private static void handler(Socket socket) throws IOException {
        System.out.println("线程id= " + Thread.currentThread().getId());
        byte[] bytes = new byte[1024];

        System.out.println("开始read。。");
        //接收客户端的数据，如果没有读取到客户端数据时，该方法也会阻塞
        int read = socket.getInputStream().read(bytes);
        System.out.println("read结束");
        if (read != -1) {
            System.out.println("接收到客户端的数据：" + new String(bytes, 0, read));
            System.out.println("线程id= = " + Thread.currentThread().getId());

        }
        socket.getOutputStream().write("效果演示完毕~~".getBytes());
        socket.getOutputStream().flush();
    }
}

四、NIO(Non Blocking IO) 同步非阻塞

NIO同步非阻塞的原理：多个客户端发送连接请求注册到（多路复用器）selector中，
多路复用器使用轮训机制实现检测每个io请求有数据就进行处理。
底层实现原理：
I/O多路复用底层一般用的Linux API（select，poll，epoll）来实现

NIO 有三大核心组件： Channel(通道)， Buffer(缓冲区)，Selector(选择器)

1.Channel(通道) :称之为通道，和IO相连，通信双方进行数据交流的通道，需要和buffer结合使用。
2.Buffer(缓冲区) :对数据的读取/写入需要使用buffer，buffer本质就是一个数组。
3.Selector(选择器): IO多路复用 一个线程Thread使用选择器Selector通过轮询的方式去监听多个通道Channel上的事件，从而让一个线程可以处理多个事件。

1. 简单模拟NIO底层代码实现

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;

/**
 * 模拟伪装nio底层原理
 * SocketNioTcpServer
 */
public class SimulationNioTcpServer {

    /**
     * 保存SocketChannel
     */
    private static List<SocketChannel> listSocketChannel = new ArrayList<>();
    /**
     * 缓冲区大小
     */
    private static ByteBuffer byteBuffer = ByteBuffer.allocate(512);

    public static void main(String[] args) {
        try {
            // 1.创建一个ServerSocketChannel
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            // 2. 绑定地址
            ServerSocketChannel bind = serverSocketChannel.bind(new InetSocketAddress(8080));
            // 3.设置非阻塞模式
            serverSocketChannel.configureBlocking(false);
            while (true) {
                // 4.等待建立连接  如果设置非阻塞的情况下，如果没有获取连接的情况下直接返回null，如果建立连接之后返回socketChannel
                // 建立三次握手
                SocketChannel socketChannel = serverSocketChannel.accept();
                // 5. 如果socketChannel 不为空的情况下，则将该连接保存起来。
                if (socketChannel != null) {
                    // 设置该socketChannel通道为fasle
                    socketChannel.configureBlocking(false);
                    listSocketChannel.add(socketChannel);
                }
                // 循环SocketChannel,检查每个SocketChannel中数据有传输数据
                for (SocketChannel scl : listSocketChannel) {
                    try {
                        // 6.以缓冲区方式读取
                        int read = scl.read(byteBuffer);
                        if (read > 0) {
                            byteBuffer.flip();
                            // 转换格式为中文的格式
                            Charset charset = Charset.forName("UTF-8");
                            String receiveText = charset.newDecoder().decode
                                    (byteBuffer.asReadOnlyBuffer()).toString();
                            System.out.println("receiveText:" + receiveText);
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2. 选择器IO多路复用底层原理

IO多路复用 一个线程Thread使用选择器Selector通过轮询的方式去监听多个通道Channel上的事件，从而让一个线程可以处理多个事件。

I/O多路复用底层一般用的Linux API（select，poll，epoll）来实现

1. 使用select的情况下，底层采用该数组方式存放 每次调用遍历的时间复杂度就是为O(n),有可能会产生空轮训，比如 保存1万个连接，最终只有1个连接有传输数据。

2. 使用poll底层采用链表结构存放，每次调用遍历的时间复杂度就是为O(n)
   Poll与select之间区别不是很大；select监视器单个进程可监视的fd数量被限制
   可以通过cat /proc/sys/fs/file-max， poll 是没有监视的fd数量限制。
   Linux服务器中创建Socket服务器端 单个select进程可监事的fd（连接数据）限制

3. epoll采用事件通知回调方式，避免空轮休时间复杂度为o(1);

注意：windows *** 作系统是没有epoll，只有linux系统才有epoll