Java中NIO及基础实现

NIO:同步非壅闭IO

来源：BIO是同步壅闭IO利用，当线程在处理使命时，另一方会壅闭着等待该线程的执行完毕，为了进步效率，，JDK1.4后，引入NIO来提升数据的通讯性能

NIO中接纳Reactor计划模式，注册的汇集点为Selector，NIO有三个紧张构成部门：Channel（通道）、Buffer（缓冲区）、Selector（选择器）

Reactor计划模式：Reactor模式是一种被动事件处理模式，即当某个特定事件发生时触发事件，可参考，https://blog.csdn.net/feimataxue/article/details/7642638，https://www.cnblogs.com/bitkevin/p/5724410.html

NIO接纳了轮询的方式来观察事件是否执行完毕，如：A让B打印某个文件，BIO会不停等待着B返回，期间自己不做其他事变，而NIO则会不停的询问B是否完成，未完成则处理自己的时，直至B完成

Channel（通道）：Channel是一个对象，可以通过它读取和写入数据

Selector（对象选择器）： Selector是一个对象，它可以注册到很多个Channel上，监听各个Channel上发生的事件，并且可以或许根据事件情况决定Channel读写

代码实现：（此实现参考网络上可用的例子）

NIO客户端实现：

1. package com.learn.nio.client;
3. import com.study.info.HostInfo;
4. import com.study.util.InputUtil;
6. import java.net.InetSocketAddress;
7. import java.nio.ByteBuffer;
8. import java.nio.channels.SocketChannel;
10. public class NIOEchoClient {
12. public static void main(String[] args) throws Exception{
13. SocketChannel clientChannel = SocketChannel.open();
14. clientChannel.connect(new InetSocketAddress(HostInfo.HOST_NAME,HostInfo.PORT));
15. ByteBuffer buffer = ByteBuffer.allocate(50);
16. boolean flag = true;
17. while (flag){
18. buffer.clear();
19. String input = InputUtil.getString("请输入待发送的信息：").trim();
20. buffer.put(input.getBytes()); //将数据存入缓冲区
21. buffer.flip(); // 重置缓冲区
22. clientChannel.write(buffer); //发送数据
23. buffer.clear();
24. int read = clientChannel.read(buffer);
25. buffer.flip();
26. System.err.print(new String(buffer.array(), 0, read));
27. if("byebye".equalsIgnoreCase(input)){
28. flag = false;
29. }
30. }
31. clientChannel.close();
32. }
33. }

复制代码

NIO服务端实现：

1. package com.learn.nio.server;
3. import com.study.info.HostInfo;
5. import java.net.InetSocketAddress;
6. import java.nio.ByteBuffer;
7. import java.nio.channels.SelectionKey;
8. import java.nio.channels.Selector;
9. import java.nio.channels.ServerSocketChannel;
10. import java.nio.channels.SocketChannel;
11. import java.util.Iterator;
12. import java.util.Set;
13. import java.util.concurrent.ExecutorService;
14. import java.util.concurrent.Executors;
16. public class NIOEchoServer {
18. private static class EchoClientHandle implements Runnable {
20. //客户端
21. private SocketChannel clientChannel;
22. // 循环竣事标记
23. private boolean flag = true;
24. public EchoClientHandle(SocketChannel clientChannel){
25. this.clientChannel = clientChannel;
26. }
28. @Override
29. public void run() {
30. ByteBuffer byteBuffer = ByteBuffer.allocate(50);
31. try {
32. while (this.flag){
33. byteBuffer.clear();
34. int read = this.clientChannel.read(byteBuffer);
35. String msg = new String(byteBuffer.array(), 0, read).trim();
36. String outMsg = "【Echo】" + msg + "\n"; // 回应信息
37. if("byebve".equals(msg)){
38. outMsg = "会话竣事，下次再见！";
39. this.flag = false;
40. }
41. byteBuffer.clear();
42. byteBuffer.put(outMsg.getBytes()); //回传信息放入缓冲区
43. byteBuffer.flip();
44. this.clientChannel.write(byteBuffer);// 回传信息
45. }
46. }catch (Exception e){
47. e.printStackTrace();
48. }
49. }
50. }
52. public static void main(String[] args) throws Exception{
53. // 为了性能问题及相应时间，设置固定大小的线程池
54. ExecutorService executorService = Executors.newFixedThreadPool(10);
55. // NIO基于Channel控制，所以有Selector管理全部的Channel
56. ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
57. // 设置为非壅闭模式
58. serverSocketChannel.configureBlocking(false);
59. // 设置监听端口
60. serverSocketChannel.bind(new InetSocketAddress(HostInfo.PORT));
61. // 设置Selector管理全部Channel
62. Selector selector = Selector.open();
63. // 注册并设置毗连时处理
64. serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
65. System.out.println("服务启动乐成，监听端口为：" + HostInfo.PORT);
66. // NIO使用轮询，当有请求毗连时，则启动一个线程
67. int keySelect = 0;
68. while ((keySelect = selector.select()) > 0){
69. Set<SelectionKey> selectionKeys = selector.selectedKeys();
70. Iterator<SelectionKey> iterator = selectionKeys.iterator();
71. while (iterator.hasNext()){
72. SelectionKey next = iterator.next();
73. if(next.isAcceptable()){ // 假如是毗连的
74. SocketChannel accept = serverSocketChannel.accept();
75. if(accept != null){
76. executorService.submit(new EchoClientHandle(accept));
77. }
78. iterator.remove();
79. }
80. }
81. }
82. executorService.shutdown();
83. serverSocketChannel.close();
84. }
85. }

复制代码

工具类：

1. package com.study.util;
3. import java.io.BufferedReader;
4. import java.io.IOException;
5. import java.io.InputStreamReader;
7. public class InputUtil {
8. private static final BufferedReader KEYBOARD_INPUT = new BufferedReader(new InputStreamReader(System.in));
10. private InputUtil(){
11. }
13. public static String getString(String prompt){
14. boolean flag = true; //数据接受标记
15. String str = null;
16. while (flag){
17. System.out.println(prompt);
18. try {
19. str = KEYBOARD_INPUT.readLine(); // 读取一行数据
20. if(str == null || "".equals(str)){
21. System.out.println("数据输入错误，不允许为空！");
22. }else {
23. flag = false;
24. }
25. } catch (IOException e) {
26. e.printStackTrace();
27. }
28. }
29. return str;
30. }
31. }

复制代码

1. package com.study.info;
3. public calss HostInfo {
4. public static final String HOST_NAME = "localhost";
5. public static final int PORT = 9999;
6. }

复制代码

NIO结构参考文章： https://www.cnblogs.com/sxkgeek/p/9488703.html#_label2

来源：https://www.cnblogs.com/shlearn/p/11689427.html