浅谈java中nio的使用方式

一时失言乱红尘 2022-06-11 08:36 163阅读 0赞

NIO里主要包括两个方面的内容，一方面是在网络连接方面，借鉴了操作系统（类似epoll方式）来注册事件机制； 另一方面是文件I/O，原来是只能一个字节一个字节的读（读出来后自己可以做buffer),  而NIO中可以批量一次性读出或写入.

NIO 同时 也是 非阻塞的,  意义在于可以使用一个线程对大量的数据连接进行处理,非常适用于"短数据长连接"的应用场景,例如即时通讯软件.

由于 我们在java中大多数学习的都是io方面的知识, 在这里 我们来浅谈一下io与nio的区别:

面向流与面向缓冲

Java NIO和IO之间第一个最大的区别是，IO是面向流的，NIO是面向缓冲区的. Java IO面向流意味着每次从流中读一个或多个字节，直至读取所有字节，它们没有被缓存在任何地方.此外，它不能前后移动流中的数据.如果需要前后移动从流中读取的数据，需要先将它缓存到一个缓冲区. Java NIO的缓冲导向方法略有不同.数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动.这就增加了处理过程中的灵活性.但是，还需要检查是否该缓冲区中包含所有您需要处理的数据.而且，需确保当更多的数据读入缓冲区时，不要覆 盖缓冲区里尚未处理的数据.

阻塞与非阻塞 IO

Java IO的各种流是阻塞的.这意味着，当一个线程调用read() 或 write()时，该线程被阻塞，直到有一些数据被读取，或数据完全写入.该线程在此期间不能再干任何事情了. Java NIO的非阻塞模式，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取.而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情. 非阻塞写也是如此.一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情. 线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作，所以一个单独的线程现在可以管理多个输入和输出通道（channel）.

在一个阻塞C/S系统中,服务器要为每一个客户连接开启一个线程阻塞等待客户端发送的消息.若使用非阻塞技术,服务器可以使用一个线程对连接进行轮 询,无须阻塞等待.这大大减少了内存资源的浪费,也避免了服务器在客户线程中不断切换带来的CPU消耗,服务器对CPU的有效使用率大大提高.

NIO其核心概念包括Channel,Selector,SelectionKey,Buffer.

Channel是I/O通道,可以向其注册Selector,应用成功可以通过select操作获取当前通道已经准备好的可以无阻塞执行的操作.这由SelectionKey表示.

SelectionKey的常量字段SelectionKey.OP\_\*\*\*分别对应Channel的几种操作例如connect(),accept(),read(),write().

select操作后得到SelectionKey.OP\_WRITE或者READ即可在Channel上面无阻塞调用read和write方 法,Channel的读写操作均需要通过Buffer进行.即读是讲数据从通道中读入Buffer然后做进一步处理.写需要先将数据写入Buffer然后 通道接收Buffer.

通过下面 这个示例,实现一个简单的C/S,客户端想服务器端发送消息,服务器将收到的消息打印到控制台.现实的应用中需要定义发送数据使用的协议,以帮助服 务器解析消息.本示例只是无差别的使用默认编码将收到的字节转换字符并打印.通过改变初始分配的ByteBuffer的容量,可以看到打印消息的变化.容 量越小,对一条消息的处理次数就越多,容量大就可以在更少的循环次数内读完整个消息.所以真是的应用场景,要考虑适当的缓存大小以提高效率.

1.  package testnio;  
    
2.    
    
3.  import java.io.IOException;  
    
4.  import java.net.InetSocketAddress;  
    
5.  import java.nio.ByteBuffer;  
    
6.  import java.nio.channels.SelectionKey;  
    
7.  import java.nio.channels.Selector;  
    
8.  import java.nio.channels.ServerSocketChannel;  
    
9.  import java.nio.channels.SocketChannel;  
    
10. import java.util.\*;  
    
11. import java.util.concurrent.ConcurrentHashMap;  
    
12.   
    
13. public class Server \{  
    
14.         private Selector selector;  
    
15.         private ByteBuffer readBuffer = ByteBuffer.allocate(8);  
    
16.         private Map<SocketChannel, byte\[\]> clientMessage = new ConcurrentHashMap<>();  
    
17.   
    
18.         public void start() throws IOException \{  
    
19.                 ServerSocketChannel ssc = ServerSocketChannel.open();  
    
20.                 ssc.configureBlocking(false);  
    
21.                 ssc.bind(new InetSocketAddress("localhost", 8866));  
    
22.                 selector = Selector.open();  
    
23.                 ssc.register(selector, SelectionKey.OP\_ACCEPT);  
    
24.                 while (!Thread.currentThread().isInterrupted()) \{  
    
25.                         selector.select();  
    
26.                         Set<SelectionKey> keys = selector.selectedKeys();  
    
27.                         Iterator<SelectionKey> keyIterator = keys.iterator();  
    
28.                         while (keyIterator.hasNext()) \{  
    
29.                                 SelectionKey key = keyIterator.next();  
    
30.                                 if (!key.isValid()) \{  
    
31.                                         continue;  
    
32.                                 \}  
    
33.                                 if (key.isAcceptable()) \{  
    
34.                                         accept(key);  
    
35.                                 \} else if (key.isReadable()) \{  
    
36.                                         read(key);  
    
37.                                 \}  
    
38.                                 keyIterator.remove();  
    
39.                         \}  
    
40.                 \}  
    
41.         \}  
    
42.   
    
43.         private void read(SelectionKey key) throws IOException \{  
    
44.                 SocketChannel socketChannel = (SocketChannel) key.channel();  
    
45.   
    
46.                 this.readBuffer.clear();  
    
47.   
    
48.                 int numRead;  
    
49.                 try \{  
    
50.                         numRead = socketChannel.read(this.readBuffer);  
    
51.                 \} catch (IOException e) \{  
    
52.                         key.cancel();  
    
53.                         socketChannel.close();  
    
54.                         clientMessage.remove(socketChannel);  
    
55.                         return;  
    
56.                 \}  
    
57.   
    
58.                 byte\[\] bytes = clientMessage.get(socketChannel);  
    
59.                 if (bytes == null) \{  
    
60.                         bytes = new byte\[0\];  
    
61.                 \}  
    
62.                 if (numRead > 0) \{  
    
63.                         byte\[\] newBytes = new byte\[bytes.length + numRead\];  
    
64.                         System.arraycopy(bytes, 0, newBytes, 0, bytes.length);  
    
65.                         System.arraycopy(readBuffer.array(), 0, newBytes, bytes.length, numRead);  
    
66.                         clientMessage.put(socketChannel, newBytes);  
    
67.                         System.out.println(new String(newBytes));  
    
68.                 \} else \{  
    
69.                         String message = new String(bytes);  
    
70.                         System.out.println(message);  
    
71.                 \}  
    
72.         \}  
    
73.   
    
74.         private void accept(SelectionKey key) throws IOException \{  
    
75.                 ServerSocketChannel ssc = (ServerSocketChannel) key.channel();  
    
76.                 SocketChannel clientChannel = ssc.accept();  
    
77.                 clientChannel.configureBlocking(false);  
    
78.                 clientChannel.register(selector, SelectionKey.OP\_READ);  
    
79.                 System.out.println("a new client connected");  
    
80.         \}  
    
81.   
    
82.         public static void main(String\[\] args) throws IOException \{  
    
83.                 System.out.println("server started...");  
    
84.                 new Server().start();  
    
85.         \}  
    
86. \}

复制代码