上一篇我们介绍了传统IO的网络信息传输方式,分析出了传统IO网络传输的一些缺点,下面我们就介绍一下基于新型IO的网络传输方式,来弥补传统IO的不足。
NIO的官方介绍:
NIO全称java non-blocking IO,是指jdk1.4 及以上版本里提供的新api(New IO) ,为所有的原始类型(boolean类型除外)提供缓存支持的数据容器,使用它可以提供非阻塞式的高伸缩性网络。
我们先通过一个代码实例进行了解。在之前的“IOServer”工程下创建一个“cn.com.io.nio”包,然后新建一个名为“New_IO_Server”的类:
该类代码如下:
我们来简单分析一下上面的代码:
在启动服务的main方法中可以看到,一开始我们调用了initServer方法用于初始化服务端信息,做了以下事情:
(1)打开一个ServerSocket通道,并设置为非阻塞
(2)将通道对应的ServerSocket绑定到port端口,这个端口就是服务端对外服务的端口
(3)然后获得一个通道管理器,并注册一个SelectionKey.OP_ACCEPT事件,用于监听
客户端发送过来的不同类型的请求。
然后又调用了listen进行客户端监听,采取轮询的方式监听selector是否有需要处理的事件,
如果有,则进行处理。
这里监听的就是两种主要请求类型:
(1)连接请求:客户端对服务端的连接请求
(2)数据读取:客户端向服务端发送了信息,服务端接受并解析
处理连接请求就进行通道获取和阻塞类型设置,并设置通道读的权限。
处理可读事件就创建缓冲区读取客户端信息。
形象一点,整个过程就是,服务端(餐厅)初始化一个(服务员)selector(选择器,用于服务所有客户端),注册一个OP_ACCEPT的KEY(老板口头交代服务员要接待大门进来的新客人),意味着出现连接事件(客人来)的时候,selector需要去处理连接事件(接待客人),并听取客户端的各种信息(建立连接还是点菜),当接受连接请求类型(找位子准备点餐)时,为客户端进行注册(准备接受客户点菜);当接受读取事类型(顾客点菜)时,听取客户端(顾客)的具体点餐信息。
在NIO中可以设置每个连接通道为“非阻塞”状态,这就意味着使用一个单线程,就可以开启多个客户端进行服务端的连接,不存在一个客户端一直占用单线程的情况。我们运行上面的代码,使用CMD的telnet试验一下:
发现是可以同时连接服务端的。
------摘自:https://www.cnblogs.com/xiaoxi/p/6576588.html------
下表总结了Java IO和NIO之间的主要区别:
IO NIO
面向流 面向缓冲
阻塞IO 非阻塞IO
无 选择器
1、面向流与面向缓冲
Java IO和NIO之间第一个最大的区别是,IO是面向流的,NIO是面向缓冲区的。
Java IO面向流意味着每次从流中读一个或多个字节,直至读取所有字节,它们没有被缓存在任何地方:
此外,它不能前后移动流中的数据。如果需要前后移动从流中读取的数据,需要先将它缓存到一个缓冲区。
Java NIO的缓冲导向方法略有不同。数据读取到一个它稍后处理的缓冲区,需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性:
但是,还需要检查是否该缓冲区中包含所有您需要处理的数据。而且,需确保当更多的数据读入缓冲区时,不要覆盖缓冲区里尚未处理的数据。
2、阻塞与非阻塞IO
Java IO的各种流是阻塞的。这意味着,当一个线程调用read() 或 write()时,该线程被阻塞,直到有一些数据被读取,或数据完全写入。该线程在此期间不能再干任何事情了:
Java NIO的非阻塞模式,使一个线程从某通道发送请求读取数据,但是它仅能得到目前可用的数据,如果目前没有数据可用时,就什么都不会获取,而不是保持线程阻塞,所以直至数据变的可以读取之前,该线程可以继续做其他的事情。
非阻塞写也是如此。一个线程请求写入一些数据到某通道,但不需要等待它完全写入,这个线程同时可以去做别的事情。 线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作,所以一个单独的线程现在可以管理多个输入和输出通道(channel)。
3、选择器(Selectors)
Java NIO的选择器允许一个单独的线程来监视多个输入通道,你可以注册多个通道使用一个选择器,然后使用一个单独的线程来“选择”通道:这些通道里已经有可以处理的输入,或者选择已准备写入的通道。这种选择机制,使得一个单独的线程很容易来管理多个通道。
------摘自:https://www.cnblogs.com/xiaoxi/p/6576588.html------
对于传统IO和NIO,网上有一对图片表达的非常好:
我们的系统就相当于一个餐厅,大门相当于ServerSocket,客人相当于socket客户端,服务员相当于每个socket客户端的处理线程。当在多线程的情况下处理客户端的时候,就相当于餐厅每一个客人都配备了一个专门的服务员,这不管对系统还是餐厅,都是很大的开销。
而对于NIO:
NIO的官方介绍:
NIO全称java non-blocking IO,是指jdk1.4 及以上版本里提供的新api(New IO) ,为所有的原始类型(boolean类型除外)提供缓存支持的数据容器,使用它可以提供非阻塞式的高伸缩性网络。
我们先通过一个代码实例进行了解。在之前的“IOServer”工程下创建一个“cn.com.io.nio”包,然后新建一个名为“New_IO_Server”的类:
![](https://i-blog.csdnimg.cn/blog_migrate/2ed8f90fed195647aa8a563525806ecf.png)
该类代码如下:
package cn.com.io.nio;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
public class New_IO_Server {
//通道通信
private Selector selector;
/**
* 获得一个ServerSocket通道,并对该通道做一些初始化的工作
* @param port 绑定的端口号
* @throws IOException
* */
public void initServer(int port) throws IOException {
//获得一个ServerSocket通道
ServerSocketChannel serverChannel = ServerSocketChannel.open();
//设置通道为非阻塞
serverChannel.configureBlocking(false);
//将通道对应的ServerSocket绑定到port端口
serverChannel.socket().bind(new InetSocketAddress(port));
//获得一个通道管理器
this.selector = Selector.open();
//将通道管理器和该通道绑定,并为该通道注册SelectionKey.OP_ACCEPT事件,注册该事件后,
//当该事件到达时,selector.select()会返回,如果该事件没到达selector.select()会一直阻塞
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
}
/**
* 采用轮询的方式监听selector是否有需要处理的事件,如果有,则进行处理
* @throws IOException
* */
public void listen() throws IOException{
System.out.println("服务端启动成功!");
//轮询访问selector
while(true){
//当注册的事件到达时,方法返回;否则,该方法会一直阻塞
selector.select();
//获得selector中选中的项的迭代器,选中的项为注册的事件
Iterator<?> ite = this.selector.selectedKeys().iterator();
while(ite.hasNext()){
SelectionKey key = (SelectionKey)ite.next();
//删除已选的key,以防重复处理
ite.remove();
handler(key);
}
}
}
/**
* 处理请求
* @param key
* @throws IOException
* */
private void handler(SelectionKey key) throws IOException{
if(key.isAcceptable()){//客户端请求连接事件
handlerAccept(key);
}else if(key.isReadable()){//获得了可读的事件
handlerRead(key);
}
}
/**
* 处理连接请求
* @param key
* @throws IOException
* */
private void handlerAccept(SelectionKey key) throws IOException {
//获得ServerSocket
ServerSocketChannel server = (ServerSocketChannel) key.channel();
//获得和客户端连接的通道
SocketChannel channel = server.accept();
//设置成非阻塞
channel.configureBlocking(false);
System.out.println("新的客户端连接");
//服务端发给客户端的确认信息
channel.write(ByteBuffer.wrap("服务端成功创建连接".getBytes()));
//在和客户端连接成功后,为了可以接收到客户端的信息,需要给通道设置读的权限
channel.register(this.selector, SelectionKey.OP_READ);
}
/**
* 处理可读的事件
* @param key
* @throws IOException
* */
private void handlerRead(SelectionKey key) throws IOException {
//得到事件发生的Socket通道
SocketChannel channel = (SocketChannel) key.channel();
//创建读取的缓冲区(每次读1000个字节)
ByteBuffer buffer = ByteBuffer.allocate(1000);
channel.read(buffer);
byte[] data = buffer.array();
String msg = new String(data).trim();
System.out.println("服务端收到信息:"+msg);
ByteBuffer outBuffer = ByteBuffer.wrap(("服务端收到信息:"+msg).getBytes());
channel.write(outBuffer);//将消息送回给客户端
}
/**
* 启动服务测试
* @throws IOException
* */
public static void main(String[] args) throws IOException {
New_IO_Server server = new New_IO_Server();
server.initServer(10010);
server.listen();
}
}
在上面的代码中,出现了许多与传统IO不同的API,其中ServerSocketChannel类似传统IO的ServerSocket,而SocketChannel类似传统IO的Socket。而出现的Selector以及SelectionKey相当于“选择器”和“选择事件类型”。是用来让一个单独的线程来“选择”通道的,这种选择机制,使得一个单独的线程很容易来管理多个通道。
我们来简单分析一下上面的代码:
在启动服务的main方法中可以看到,一开始我们调用了initServer方法用于初始化服务端信息,做了以下事情:
(1)打开一个ServerSocket通道,并设置为非阻塞
(2)将通道对应的ServerSocket绑定到port端口,这个端口就是服务端对外服务的端口
(3)然后获得一个通道管理器,并注册一个SelectionKey.OP_ACCEPT事件,用于监听
客户端发送过来的不同类型的请求。
然后又调用了listen进行客户端监听,采取轮询的方式监听selector是否有需要处理的事件,
如果有,则进行处理。
这里监听的就是两种主要请求类型:
(1)连接请求:客户端对服务端的连接请求
(2)数据读取:客户端向服务端发送了信息,服务端接受并解析
处理连接请求就进行通道获取和阻塞类型设置,并设置通道读的权限。
处理可读事件就创建缓冲区读取客户端信息。
形象一点,整个过程就是,服务端(餐厅)初始化一个(服务员)selector(选择器,用于服务所有客户端),注册一个OP_ACCEPT的KEY(老板口头交代服务员要接待大门进来的新客人),意味着出现连接事件(客人来)的时候,selector需要去处理连接事件(接待客人),并听取客户端的各种信息(建立连接还是点菜),当接受连接请求类型(找位子准备点餐)时,为客户端进行注册(准备接受客户点菜);当接受读取事类型(顾客点菜)时,听取客户端(顾客)的具体点餐信息。
在NIO中可以设置每个连接通道为“非阻塞”状态,这就意味着使用一个单线程,就可以开启多个客户端进行服务端的连接,不存在一个客户端一直占用单线程的情况。我们运行上面的代码,使用CMD的telnet试验一下:
![](https://i-blog.csdnimg.cn/blog_migrate/b27365c0a3b7cd852ba15cc3c81d918d.png)
发现是可以同时连接服务端的。
------摘自:https://www.cnblogs.com/xiaoxi/p/6576588.html------
下表总结了Java IO和NIO之间的主要区别:
IO NIO
面向流 面向缓冲
阻塞IO 非阻塞IO
无 选择器
1、面向流与面向缓冲
Java IO和NIO之间第一个最大的区别是,IO是面向流的,NIO是面向缓冲区的。
Java IO面向流意味着每次从流中读一个或多个字节,直至读取所有字节,它们没有被缓存在任何地方:
![](https://i-blog.csdnimg.cn/blog_migrate/3082ccbc1386d891ee9519c8e7dd6373.png)
此外,它不能前后移动流中的数据。如果需要前后移动从流中读取的数据,需要先将它缓存到一个缓冲区。
Java NIO的缓冲导向方法略有不同。数据读取到一个它稍后处理的缓冲区,需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性:
![](https://i-blog.csdnimg.cn/blog_migrate/fc207393da01d975f8dc46ff3d4c07da.png)
但是,还需要检查是否该缓冲区中包含所有您需要处理的数据。而且,需确保当更多的数据读入缓冲区时,不要覆盖缓冲区里尚未处理的数据。
2、阻塞与非阻塞IO
Java IO的各种流是阻塞的。这意味着,当一个线程调用read() 或 write()时,该线程被阻塞,直到有一些数据被读取,或数据完全写入。该线程在此期间不能再干任何事情了:
![](https://i-blog.csdnimg.cn/blog_migrate/8fd617a69feb3f18917275493fd92935.png)
Java NIO的非阻塞模式,使一个线程从某通道发送请求读取数据,但是它仅能得到目前可用的数据,如果目前没有数据可用时,就什么都不会获取,而不是保持线程阻塞,所以直至数据变的可以读取之前,该线程可以继续做其他的事情。
![](https://i-blog.csdnimg.cn/blog_migrate/62b0efae87d45598c4119479a384e036.png)
非阻塞写也是如此。一个线程请求写入一些数据到某通道,但不需要等待它完全写入,这个线程同时可以去做别的事情。 线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作,所以一个单独的线程现在可以管理多个输入和输出通道(channel)。
3、选择器(Selectors)
Java NIO的选择器允许一个单独的线程来监视多个输入通道,你可以注册多个通道使用一个选择器,然后使用一个单独的线程来“选择”通道:这些通道里已经有可以处理的输入,或者选择已准备写入的通道。这种选择机制,使得一个单独的线程很容易来管理多个通道。
------摘自:https://www.cnblogs.com/xiaoxi/p/6576588.html------
对于传统IO和NIO,网上有一对图片表达的非常好:
![](https://i-blog.csdnimg.cn/blog_migrate/3b184d78a4f60674019dcf3d49db2f07.png)
我们的系统就相当于一个餐厅,大门相当于ServerSocket,客人相当于socket客户端,服务员相当于每个socket客户端的处理线程。当在多线程的情况下处理客户端的时候,就相当于餐厅每一个客人都配备了一个专门的服务员,这不管对系统还是餐厅,都是很大的开销。
而对于NIO:
![](https://i-blog.csdnimg.cn/blog_migrate/095ddcb4bd6fc4007fe4cf16bc1809e5.png)
这里也是将系统比喻为一个餐厅,大门相当于serverChannel.socket().bind(new InetSocketAddress(10010)),客人相当于SocketChannel客户端,服务员相当于线程和selector,只需要一个服务员就可以服务所有的客人了,这对于系统或餐厅来说都是一个低开销的事情。
转载请注明出处:https://blog.csdn.net/acmman/article/details/80039201