请不要再说NIO和多路复用IO是同一个东西了（内含BIO、NIO、多路复用、Netty、AIO案例测试代码）

一、写在最前面

1、误区

在我阅读了网上很多关于NIO和多路复用的文章，发现很多文章的语言存在歧义。如果不信，请你回答下列问题：

1、请问有几种IO模型

答：BIO、NIO、多路复用、信号驱动IO、异步IO

2、请问你如何理解NIO

答：你可能会说对应的select、poll甚至是epoll概念，然后引申到Netty

3、请问你如何理解多路复用

答：你就会把多路复用的基本概念说一遍，甚至还可以引申到redis的多路复用机制

4、请问NIO和多路复用IO的区别是什么

答：。。。

这是发生在我周围的例子，有人甚至给我的回答是——多路复用就是NIO，我也不能说他错，也不能说他对。

2、IO模型分类

主要是网上的博客表述有歧义，导致很多人理不清这几种IO模型的关系。回到第一个问题，有几种IO模型。

在《UNIX网络编程卷1》的第六章对IO模型给BIO、NIO、多路复用、信号驱动IO、异步IO五种IO模型给出了如下的定义：

3、概念再梳理（重点）

不知道你发现没有，NIO中根本没有提及select、poll甚至是epoll，反而是在多路复用中提到了他们。NIO的定义只包含了一个空轮询，会不断的去获取数据。

那为什么网上很多博客还在说NIO含有select呢？

这里一定要区分，我们所说的IO模型，是从网络层面来说的，而很多博客中的NIO是Java规范里面的。这就好比线程有多少种状态？在操作系统层面，你可以说有新建、可运行、运行、阻塞、死亡这五种。但在Java层面，你就会回答New(新创建)、Runnable(可运行)、Blocked(被阻塞)、Waiting(等待)、Tilme waiting(计时等待)、Terminated(已终止)这六种。

同理如果你问的是Java层面的NIO，那么我们就可以要理解为是java.nio这个包下面的代码，这里就可以说出我们NIO的三大组件——Buffer、Channel、Selector。即Java里面的NIO（NIO包下面的代码）就是封装了多路复用的机制。同理Netty是基于网络层面的多路复用机制，是基于Java层面的NIO。

二、BIO（Blocking IO）

1、客户端

@Slf4j
public class BioClient {

	public static void main(String[] args) throws IOException {
		Socket socket = new Socket("127.0.0.1", 9099);
		// 向服务端发送数据
		socket.getOutputStream().write("Hello BioServer".getBytes());
		socket.getOutputStream().flush();
		log.info("向服务端发送数据结束");
		byte[] bytes = new byte[1024];
		//接收服务端回传的数据
		socket.getInputStream().read(bytes);
		log.info("接收到服务端返回的数据：{}", new String(bytes));
		socket.close();
	}
}

2、服务端

@Slf4j
public class BioServer {
	public static void main(String[] args) throws IOException {
		ServerSocket serverSocket = new ServerSocket(9099);
		while (true) {
			log.info("等待客户端连接");
			//阻塞方法
			Socket socket = serverSocket.accept();
			log.info("客户端连接成功");
			new Thread(() -> {
				try {
					handler(socket);
				} catch (IOException e) {
					log.error(e.getMessage(), e);
				}
			}).start();

		}
	}

	private static void handler(Socket socket) throws IOException {
		byte[] bytes = new byte[1024];

		log.info("开始读取数据");
		// 接收客户端的数据，阻塞方法，没有数据可读时就阻塞
		int read = socket.getInputStream().read(bytes);
		log.info("读取数据完毕");
		if (read != -1) {
			log.info("接收到客户端的数据：{}", new String(bytes, 0, read));
		}
		// 向outputStream中回写数据
		socket.getOutputStream().write("Hello BioClient".getBytes());
		socket.getOutputStream().flush();
	}
}

3、效果展示

根据测试结果，我们不难发现，BIO的服务端是阻塞获取新请求。结合代码，没接收到一个新请求，就开启一个线程读取对应的数据。

服务端：

客户端：

4、总结

在BIO模式下，会存在一下问题：

问题一：只能以阻塞的形式读取每一次的请求。

问题二：如果客户端发送的数据为0，那么服务端在读取数据的时候也会阻塞读取，直到获取到数据才会向下执行，即下面这行代码也是阻塞的。

int read = socket.getInputStream().read(bytes);

BIO升级为每接收到一个连接，就开启一个线程

问题三：并发请求10W个连接，此时就会开启10W个线程，资源耗费极大

问题四：和问题二相同，如果其中一个线程迟迟没有获取到数据，这就会导致部分线程卡死

BIO再次升级，升级为一个线程池的使用

问题五：虽然线程池能够解决线程开启和释放的性能损耗，但是依然会出现问题四

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

三、NIO（NonBlocking IO）

1、客户端

@Slf4j
public class NioClient {
	public static void main(String[] args) throws IOException {


		SocketChannel sc = SocketChannel.open();
		sc.connect(new InetSocketAddress("localhost", 8099));

		sc.write(Charset.defaultCharset().encode("Hello NioServer"));
		log.info("发送数据成功");
		ByteBuffer buffer = ByteBuffer.allocate(16);

		int read = sc.read(buffer);
		if (read > 0) {
			log.info("读取到服务端返回的 {} 长度的数据", read);
		}

		sc.write(Charset.defaultCharset().encode("Hello NioServer2"));
		log.info("再次发送数据成功");

		System.in.read(); // 阻塞线程
	}
}

2、服务端

@Slf4j
public class NioServer {

	public static void main(String[] args) throws IOException, InterruptedException {
		ByteBuffer buffer = ByteBuffer.allocate(16);
		ServerSocketChannel ssc = ServerSocketChannel.open();
		ssc.configureBlocking(false);// accept不会阻塞
		ssc.bind(new InetSocketAddress(8099));
		List<SocketChannel> channelList = new ArrayList<>();
		while (true) {
			log.info("开始接收请求");
			SocketChannel accept = ssc.accept();
			if (accept != null) {
				log.info("获取到对应的连接" + accept);
				accept.configureBlocking(false); // read不会阻塞
				channelList.add(accept);
			}

			for (SocketChannel channel : channelList) {
				log.info("开始读取客户端的数据", channel);
				int read = channel.read(buffer);
				if (read > 0) {
					buffer.flip();
					log.info("读取到 {} 长度的数据", read);
					ByteBuffer retBuf = ByteBuffer.wrap("Hi NioClient".getBytes());
					TimeUnit.SECONDS.sleep(5); // 阻塞线程，便于观察控制台
					channel.write(retBuf);
					buffer.clear();
					log.info("数据读取完成", channel);
				}
			}
		}
	}
}

3、效果展示

NIO区别于BIO最大的特点就是是否是阻塞获取请求（一定要区分开Java的NIO包和NIO这个概念）。NIO会不断的轮询获取请求，即控制台中不断的轮询打印开始接受请求，如果接收到数据，就会像控制台那样，直接读取对应的数据。结尾的报错是因为我关闭了客户端的连接

服务端：

客户端：

4、总结

对然NIO不再像BIO那样会阻塞线程，造成网络堵塞，但是它不停的去轮询线程，会造成CPU空转，这也是我们不想看到的。如果大量连接不涉及写数据，但此时这个线程轮询获取写入数据的操作就是无意义的。

四、多路复用（Multiplexing）

1、客户端

多路复用IO的代码稍微要复杂一点，是因为它引入了一个Selector组件，我们常听到的Reactor模式、select、poll、epoll等，都是多路复用IO机制里面的名词，本文侧重案例测试，对这些概念不再进行讲解。

多路复用客户端代码结构为：

初始化对应的与服务端的连接，这里的初始化包含初始化channel和Selector，并且完成对应事件和channel的绑定关系

开启连接，内部逻辑为依靠selector进行监听对应的事件（这就是我们所说的Reactor事件处理机制），如果监听到对应的连接信息，就根据连接中的事件进行判定，然后再执行不同的业务逻辑

@Slf4j
public class MultioClient {

	private Selector selector;

	public static void main(String[] args) throws IOException {
		MultioClient client = new MultioClient();
		client.initClient("127.0.0.1", 9099);
		client.connect();
	}

	/**
	 * 获得一个Socket通道，并对该通道做一些初始化的工作
	 *
	 * @param ip   连接的服务器的ip
	 * @param port 连接的服务器的端口号
	 */
	public void initClient(String ip, int port) throws IOException {
		// 获得一个Socket通道
		SocketChannel channel = SocketChannel.open();
		// 设置通道为非阻塞
		channel.configureBlocking(false);
		// 获得一个通道管理器
		this.selector = Selector.open();
		// 客户端连接服务器,其实方法执行并没有实现连接，需要在listen（）方法中调
		// 用channel.finishConnect() 才能完成连接
		log.info("第1步：客户端初始化，发起连接，触发连接事件请求");
		channel.connect(new InetSocketAddress(ip, port));
		// 将通道管理器和该通道绑定，并为该通道注册SelectionKey.OP_CONNECT事件（连接事件）。

		channel.register(selector, SelectionKey.OP_CONNECT);
	}

	/**
	 * 采用轮询的方式监听selector上是否有需要处理的事件，如果有，则进行处理
	 */
	public void connect() throws IOException {
		// 轮询访问selector
		while (true) {
			selector.select();
			// 获得selector中选中的项的迭代器
			Iterator<SelectionKey> it = this.selector.selectedKeys().iterator();
			while (it.hasNext()) {
				SelectionKey key = it.next();
				// 删除已选的key,以防重复处理
				it.remove();
				// 连接事件发生
				if (key.isConnectable()) {
					SocketChannel channel = (SocketChannel) key.channel();
					// 如果正在连接，则完成连接
					if (channel.isConnectionPending()) {
						channel.finishConnect();
					}
					// 设置成非阻塞
					channel.configureBlocking(false);
					// 在这里可以给服务端发送信息哦
					ByteBuffer buffer = ByteBuffer.wrap("Hello MultServer".getBytes());

					log.info("第3步：向服务端发送数据");
					channel.write(buffer);
					// 在和服务端连接成功之后，为了可以接收到服务端的信息，需要给通道设置读的权限。
					channel.register(this.selector, SelectionKey.OP_READ);  // 获得了可读的事件
				} else if (key.isReadable()) {
					log.info("第6步：读取返回的数据");
					read(key);
				}

			}
		}
	}

	/**
	 * 处理读取服务端发来的信息事件
	 *
	 * @param key
	 */
	public void read(SelectionKey key) throws IOException {
		//和服务端的read方法一样
		// 服务器可读取消息:得到事件发生的Socket通道
		SocketChannel channel = (SocketChannel) key.channel();
		// 创建读取的缓冲区
		ByteBuffer buffer = ByteBuffer.allocate(1024);
		int len = channel.read(buffer);
		if (len != -1) {
			log.info("客户端收到信息：" + new String(buffer.array(), 0, len));
		}
	}
}

2、服务端

多路复用服务端代码逻辑：

同样的先初始化出channel和selector，然后完成事件的注册。需要区分的是客户端的channel是SocketChannel，服务端的channel是ServerSocketChannel。

同样的依靠Reactor事件处理机制去监听对应的请求中的事件，然后根据事件的类型做出不同的判定

@Slf4j
public class MultioServer {


	public static void main(String[] args) throws IOException {
		// 创建一个在本地端口进行监听的服务Socket通道.并设置为非阻塞方式
		ServerSocketChannel ssc = ServerSocketChannel.open();
		// 必须配置为非阻塞才能往selector上注册，否则会报错，selector模式本身就是非阻塞模式
		ssc.configureBlocking(false);
		ssc.socket().bind(new InetSocketAddress(9099));
		// 创建一个选择器selector
		Selector selector = Selector.open();
		// 把ServerSocketChannel注册到selector上，并且selector对客户端accept连接操作感兴趣
		ssc.register(selector, SelectionKey.OP_ACCEPT);

		while (true) {
			log.info("等待事件发生——");
			// 轮询监听channel里的key，select是阻塞的，accept()也是阻塞的
			int select = selector.select();

			log.info("有事件发生——");
			// 有客户端请求，被轮询监听到
			Iterator<SelectionKey> it = selector.selectedKeys().iterator();
			while (it.hasNext()) {
				SelectionKey key = it.next();
				//删除本次已处理的key，防止下次select重复处理
				it.remove();
				handle(key);
			}
		}
	}

	/**
	 * @param key 对应的事件key
	 */
	private static void handle(SelectionKey key) throws IOException {
		if (key.isAcceptable()) {

			log.info("第2步：有客户端[连接事件]发生");
			ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
			// NIO非阻塞体现：此处accept方法是阻塞的，但是这里因为是发生了连接事件，所以这个方法会马上执行完，不会阻塞
			// 处理完连接请求不会继续等待客户端的数据发送
			SocketChannel sc = ssc.accept();
			sc.configureBlocking(false);
			// 通过Selector监听Channel时对读事件感兴趣
			sc.register(key.selector(), SelectionKey.OP_READ);
		} else if (key.isReadable()) {

			log.info("第4步：有客户端数据[可读事件]发生");
			SocketChannel sc = (SocketChannel) key.channel();
			ByteBuffer buffer = ByteBuffer.allocate(1024);
			// NIO非阻塞体现：首先read方法不会阻塞，其次这种事件响应模型，当调用到read方法时肯定是发生了客户端发送数据的事件
			int len = sc.read(buffer);
			if (len != -1) {
				log.info("读取到客户端发送的数据，可进行相应的业务处理：",new String(buffer.array(), 0, len));
			}
			// 向客户端写入数据
			ByteBuffer bufferToWrite = ByteBuffer.wrap("Hello MultClient".getBytes());
			sc.write(bufferToWrite);
			// 会触发key.isWritable() 或 key.isReadable()的条件
			key.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);
		} else if (key.isWritable()) {

			log.info("第5步：有客户端数据[写入事件]发生了");
			SocketChannel sc = (SocketChannel) key.channel();
			// NIO事件触发是水平触发
			// 使用Java的NIO编程的时候，在没有数据可以往外写的时候要取消写事件，
			// 在有数据往外写的时候再注册写事件
			key.interestOps(SelectionKey.OP_READ);
		}
	}
}

3、效果展示

代码执行逻辑为：

首先客户端会初始化，然后去连接服务端
服务端接收到对应的连接事件后
然后客户端向服务端写入数据
此时服务端接收到客户端发送过来的连接，触发可读事件（key.isReadable()）
读取完数据之后，服务端准备向客户端写入数据，此时触发服务端的可写事件，没有数据可以写入的时候取消写事件
最终客户端收到服务端写会的数据

客户端：

服务端：

4、总结

多路复用其实是一个相对完美的解决方案，即采用了Reactor模型，当对应的读、写、连接等事件触发的时候，再触发对应的接收请求的逻辑，然后完成后续的业务代码。既不会造成空轮询无效请求，也不会阻塞网络。

正式基于种种特点，Netty就在该IO模型的基础上进行封装。

五、Netty（基于多路复用IO）

1、客户端

Netty客户端代码如下，代码基本骨架都差不多

船舰对应的group，你可以理解为用来接收请求和分配工作线程的线程池组

创建对应的channel

创建需要对数据进行处理的handler。handler分为两大类：ChannelInboundHandler和ChannelOutboundHandler，你可以理解为是对管道中数据入口方向和出口方向数据的处理。

连接对应的服务端地址

sync阻塞住线程，连接好后再继续向下执行，否则就是异步进行连接

@Slf4j
public class netty客户端 {
	public static void main(String[] args) throws InterruptedException, IOException {

		new Bootstrap()
				.group(new NioEventLoopGroup())
				.channel(NioSocketChannel.class)
				.handler(new ChannelInitializer<NioSocketChannel>() {
					@Override
					protected void initChannel(NioSocketChannel ch) throws Exception {
						ch.pipeline().addLast(new StringEncoder());
						ch.pipeline().addLast(new StringDecoder());                        // inputStream
						ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
							// 接收响应消息
							@Override
							public void channelRead(ChannelHandlerContext ctx, Object msg) {
								log.info("第4步：netty客户端接收到服务端返回的数据为：{}", msg);
							}

							@Override
							public void channelActive(ChannelHandlerContext ctx) {
								log.info("第1步：客户端启动触发事件");
								ctx.writeAndFlush("Hello NettyServer");
							}
						});
					}
				})
				.connect(new InetSocketAddress("localhost", 8099))
				.sync();
	}
}

2、服务端

服务端代码格式和客户端差不多，最开始创建的Bootstrap对象变成了ServerBootstrap。同样的，核心逻辑在initChannel方法里面。

StringEncoder和StringDecoder为一个编解码器，我调用的writeAndFlush方法是直接写入的字节，需要在服务端和客户端分别对该字节进行相同格式的编解码工作，才能够收到对应的数据信息

@Slf4j
public class netty服务端 {
	public static void main(String[] args) {

		new ServerBootstrap()
				.group(new NioEventLoopGroup())
				.channel(NioServerSocketChannel.class)
				.childHandler(new ChannelInitializer<NioSocketChannel>() {
					@Override
					protected void initChannel(NioSocketChannel ch) throws Exception {
						ch.pipeline().addLast(new StringEncoder());
						ch.pipeline().addLast(new StringDecoder());
						ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {

							@Override
							public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
								log.info("第2步：服务端接收消息：{}", msg);
							}

							@Override
							public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
								log.info("第3步：服务端接收到消息后进行业务处理");
								ctx.channel().writeAndFlush("Hello NettyClient");
							}
						});
					}
				})
				.bind(8099);
	}
}

3、效果展示

服务端：

客户端：

4、总结

当你熟悉了Netty代码的编写风格之后，你会发现，我们想要对数据进行处理，只需要编写对应的ChannelHandler，其他的额外的关于数据的解析、读取等繁琐操作都被Netty封装了，即开发人员能够更加专注于业务开发，而非投身于繁琐的字节解析工作中。

想了解Netty一些细节概念的，可以参考：浅谈Netty机制

六、AIO（Asynchronous IO）

1、客户端

对应的Channel变成了AsynchronousSocketChannel

@Slf4j
public class AIOClient {

	public static void main(String... args) throws Exception {
		AsynchronousSocketChannel socketChannel = AsynchronousSocketChannel.open();
		socketChannel.connect(new InetSocketAddress("127.0.0.1", 9000)).get();
		socketChannel.write(ByteBuffer.wrap("Hello AioServer".getBytes()));
		ByteBuffer buffer = ByteBuffer.allocate(512);
		Integer len = socketChannel.read(buffer).get();
		if (len != -1) {
			log.info("客户端收到信息：" + new String(buffer.array(), 0, len));
		}
	}
}

2、服务端

@Slf4j
public class AIOServer {
    public static void main(String[] args) throws Exception {
        final AsynchronousServerSocketChannel serverChannel =
                AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(9000));

        serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {
            @Override
            public void completed(AsynchronousSocketChannel socketChannel, Object attachment) {
                try {
                    // 再此接收客户端连接，如果不写这行代码后面的客户端连接连不上服务端
                    serverChannel.accept(attachment, this);
                    log.info(socketChannel.getRemoteAddress().toString());
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    socketChannel.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
                        @Override
                        public void completed(Integer result, ByteBuffer buffer) {
                            buffer.flip();
                            log.info(new String(buffer.array(), 0, result));
                            socketChannel.write(ByteBuffer.wrap("Hello AioClient".getBytes()));
                        }

                        @Override
                        public void failed(Throwable exc, ByteBuffer buffer) {
                            exc.printStackTrace();
                        }
                    });
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void failed(Throwable exc, Object attachment) {
                exc.printStackTrace();
            }
        });

        Thread.sleep(Integer.MAX_VALUE);
    }
}

3、效果展示

演示的效果也很好理解，就是我们常规的理解的异步获取到数据。

客户端：

服务端：

4、总结

异步非阻塞，由操作系统完成后回调通知服务端程序启动线程去处理，一般适用于连接数较多且连接时间较长的应用，JDK7 开始支持。

在Linux系统上，AIO的底层实现仍使用Epoll，没有很好实现AIO，因此在性能上没有明显的优势，而且被JDK封装了一层不容易深度优化，Linux上AIO还不够成熟。Netty是异步非阻塞框架，Netty在JDK的NIO上做了很多异步的封装。

	BIO	NIO	AIO
IO模型	同步阻塞	同步非阻塞（多路复用）	异步非阻塞
编程难度	简单	复杂	复杂
可靠性	差	好	好
吞吐量	低	高	高

请不要再说NIO和多路复用IO是同一个东西了（内含BIO、NIO、多路复用、Netty、AIO案例测试代码）

文章目录

一、写在最前面

1、误区

2、IO模型分类

3、概念再梳理（重点）

二、BIO（Blocking IO）

1、客户端

2、服务端

3、效果展示

4、总结

三、NIO（NonBlocking IO）

1、客户端

2、服务端

3、效果展示

4、总结

四、多路复用（Multiplexing）

1、客户端

2、服务端

3、效果展示

4、总结

五、Netty（基于多路复用IO）

1、客户端

2、服务端

3、效果展示

4、总结

六、AIO（Asynchronous IO）

1、客户端

2、服务端

3、效果展示

4、总结

标签云

近期文章

分类

请不要再说NIO和多路复用IO是同一个东西了（内含BIO、NIO、多路复用、Netty、AIO案例测试代码）

文章目录

一、写在最前面

1、误区

2、IO模型分类

3、概念再梳理（重点）

二、BIO（Blocking IO）

1、客户端

2、服务端

3、效果展示

4、总结

三、NIO（NonBlocking IO）

1、客户端

2、服务端

3、效果展示

4、总结

四、多路复用（Multiplexing）

1、客户端

2、服务端

3、效果展示

4、总结

五、Netty（基于多路复用IO）

1、客户端

2、服务端

3、效果展示

4、总结

六、AIO（Asynchronous IO）

1、客户端

2、服务端

3、效果展示

4、总结

相关文章