博客
关于我
强烈建议你试试无所不能的chatGPT，快点击我
架构师入门笔记九 初识IO NIO AIO
阅读量：3530 次
发布时间：2019-05-20

本文共 18871 字，大约阅读时间需要 62 分钟。

 架构师入门笔记九 初识IO NIO AIO
在学习netty之前，我们要对Socket网络编程有一定的了解。这里先来了解一下 IO（BIO），NIO，AIO（NIO2.0）这几种通信的特点以及其演变的过程。

1 IO（BIO）

1.1 基础理论

IO（input/output）又称BIO（block-IO）,BIO通信模型是同步阻塞的通信模式。
Socket 又称“套接字”，应用程序通常通过“套接字”向网络发出请求或者应答网络请求（网络编程的基本模型是C/S模型，即两个进程间的通信）。
套接字之间的连接过程可以分四个步骤：服务器监听，客户端请求服务器，服务器确认，客户端确认，进行通信。
1. 服务器监听：服务器端套接字并不会定位具体的客户端套接字，而是处于等待连接的状态，实时监控网络状态。
2. 客户端请求：客户端的套接字提出连接请求，要连接的目标是服务器端的套接字。为此，客户端的套接字必须首先描述它要连接的服务器的套接字，指出服务器套接字的地址和端口号，然后向服务器套接字提出连接请求。
3. 服务器端连接确认：是指当服务器端套接字监听（接收）到客户端套接字的连接请求，它就响应客户端套接字的请求，建立一个新的线程，把服务端套接字的描述发给客户端。一个客户端对应一个线程
4. 客户端连接确认：一旦客户端确认了此描述，连接就建立好了。双方开始通信。而服务器端套接字继续处于监听状态，继续接收其他客户端套接字的连接请求。

1.2 BIO模型图（图片来源网络）

1.3 代码事例

Server端：ServerSocket通过绑定IP，启动监听端口。若一直没有接收到请求，程序会一直阻塞在accept方法。当确认客户端请求后，会新增线程去处理Socket，这也就是上面所说的套接字之间的连接过程。
[java]   
  1. import java.io.IOException;  
  2. import java.net.ServerSocket;  
  3. import java.net.Socket;  
  4. import java.util.concurrent.ArrayBlockingQueue;  
  5. import java.util.concurrent.ThreadPoolExecutor;  
  6. import java.util.concurrent.TimeUnit;  
  7.   
  8. public class MyServer {  
  9.       
  10.     private static final int PORT = 9999; // 服务器对外的端口号  
  11.       
  12.     public static void main(String[] args) {  
  13.         ServerSocket server = null;  
  14.         Socket socket = null;  
  15.         ThreadPoolExecutor executor = null;  
  16.         try {  
  17.             server = new ServerSocket(PORT); // ServerSocket 绑定IP地址，启动监听端口  
  18.             System.out.println("服务器启动.........");  
  19.             /*--------------传统的新增线程处理---------------- 
  20.             while (true) {
     
  21.                 // 服务器监听：阻塞，等待Client请求 
  22.                 socket = server.accept(); 
  23.                 System.out.println("服务器确认请求 : " + socket); 
  24.                 // 服务器连接确认：确认Client请求后，创建线程执行任务  
  25.                 new Thread(new MyServerHandler(socket)).start(); 
  26.             } 
  27.             */  
  28.             /*--------------通过线程池处理缓解高并发给程序带来的压力（伪异步IO编程）----------------*/  
  29.             executor = new ThreadPoolExecutor(10, 100, 1000, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(50));  
  30.             while (true) {  
  31.                 socket = server.accept();  
  32.                 System.out.println("多线程，服务器确认请求 : " + socket);  
  33.                 MyServerHandler myServerHandler = new MyServerHandler(socket);  
  34.                 executor.execute(myServerHandler);  
  35.             }  
  36.               
  37.         } catch (IOException e) {  
  38.             e.printStackTrace();  
  39.         } finally {  
  40.             try {  
  41.                 if (null != socket) {  
  42. //                  socket.close(); 不能关哦  
  43.                 }  
  44.                 if (null != server) {  
  45.                     server.close();  
  46.                     server = null;  
  47.                     System.out.println("服务器关闭了！！！！");  
  48.                 }  
  49.                 executor.shutdown();  
  50.             } catch (IOException e) {  
  51.                 e.printStackTrace();  
  52.             }  
  53.         }  
  54.           
  55.     }  
  56.   
  57. }  
Client端：IP地址是本地IP，端口号和Server端代码端口号保持一致。通过输出流向服务端发送数据，这里是传输一个字符串数据，然后通过输入流获取服务端返回的数据。
[java]   
  1. import java.io.BufferedReader;  
  2. import java.io.IOException;  
  3. import java.io.InputStreamReader;  
  4. import java.io.PrintWriter;  
  5. import java.net.Socket;  
  6.   
  7. public class MyClient {  
  8.       
  9.     private static int PORT = 9999;  
  10.     private static String IP_ADDRESS = "127.0.0.1";  
  11.       
  12.     public static void main(String[] args) {  
  13.         // 模拟10个客户端发送请求  
  14.         for (int i = 0; i < 10; i++) {  
  15.             clientReq(i);  
  16.         }  
  17.     }  
  18.       
  19.     private static void clientReq(int i) {  
  20.         Socket socket = null;  
  21.         BufferedReader reader = null;  
  22.         PrintWriter writer = null;  
  23.         try {  
  24.             socket = new Socket(IP_ADDRESS, PORT); // Socket 发起连接操作。连接成功后，双方通过输入和输出流进行同步阻塞式通信  
  25.             reader = new BufferedReader(new InputStreamReader(socket.getInputStream())); // 获取返回内容  
  26.             writer = new PrintWriter(socket.getOutputStream(), true);  
  27.             writer.println(i + " ----->向服务器端发送数据----->"); // 向服务器端发送数据  
  28.             System.out.println(i + " 向服务器端发送数据完毕，等待服务端返回数据 ... ... ...");  
  29.             System.out.println(i + " 客户端打印返回数据 : " + reader.readLine());  
  30.         } catch (Exception e) {  
  31.             e.printStackTrace();  
  32.         } finally {  
  33.             try {  
  34.                 if (null != reader) {  
  35.                     reader.close();  
  36.                 }  
  37.                 if (null != socket) {  
  38.                     socket.close();  
  39.                     socket = null;  
  40.                 }  
  41.             } catch (IOException e) {  
  42.                 e.printStackTrace();  
  43.             }  
  44.         }  
  45.     }  
  46.   
  47. }  
Server端处理消息线程：负责处理Client请求，这里只做简单的字符串数据返回。
[java]   
  1. import java.io.BufferedReader;  
  2. import java.io.IOException;  
  3. import java.io.InputStreamReader;  
  4. import java.io.PrintWriter;  
  5. import java.net.Socket;  
  6.   
  7. public class MyServerHandler implements Runnable{  
  8.       
  9.     private Socket socket;  
  10.       
  11.     public MyServerHandler(Socket socket) {  
  12.         this.socket = socket;  
  13.     }  
  14.   
  15.     @Override  
  16.     public void run() {  
  17.         BufferedReader reader = null;  
  18.         PrintWriter writer = null;  
  19.         try {  
  20.             reader = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));  
  21.             writer = new PrintWriter(this.socket.getOutputStream(), true);  
  22. //          System.out.println("打印客户端传来的数据 : " + reader.readLine());  加了这行代码，会导致程序无法进行  
  23.             String body = null;  
  24.             while (true) {  
  25.                 body = reader.readLine(); // 若客户端用的是 writer.print() 传值，那readerLine() 是不能获取值，细节  
  26.                 if (null == body) {  
  27.                     break;  
  28.                 }  
  29.                 System.out.println("服务端接收参数 : " + body);  
  30.                 writer.println("<-----服务器端返回数据给客户端！<-----");  
  31.             }  
  32.         } catch (IOException e) {  
  33.             e.printStackTrace();  
  34.         } finally {  
  35.             if (null != writer) {  
  36.                 writer.close();  
  37.             }  
  38.             try {  
  39.                 if (null != reader) {  
  40.                     reader.close();  
  41.                 }  
  42.                 if (null != this.socket) {  
  43.                     this.socket.close();  
  44.                     this.socket = null;  
  45.                 }  
  46.             } catch (IOException e) {  
  47.                 e.printStackTrace();  
  48.             }  
  49.         }  
  50.     }  
  51.   
  52. }  
先启动Server端，然后再启动Client端，查看打印日志。
伪异步IO编程代码打印结果：
[java]   
  1. 服务器启动.........  
  2. 多线程，服务器确认请求 : Socket[addr=/127.0.0.1,port=64417,localport=9999]  
  3. 服务端接收参数 : 0 ----->向服务器端发送数据----->  
  4. 多线程，服务器确认请求 : Socket[addr=/127.0.0.1,port=64418,localport=9999]  
  5. 服务端接收参数 : 1 ----->向服务器端发送数据----->  
  6. 多线程，服务器确认请求 : Socket[addr=/127.0.0.1,port=64419,localport=9999]  
  7. 服务端接收参数 : 2 ----->向服务器端发送数据----->  
  8. 多线程，服务器确认请求 : Socket[addr=/127.0.0.1,port=64420,localport=9999]  
  9. 服务端接收参数 : 3 ----->向服务器端发送数据----->  
  10. 多线程，服务器确认请求 : Socket[addr=/127.0.0.1,port=64421,localport=9999]  
  11. 服务端接收参数 : 4 ----->向服务器端发送数据----->  
  12. 多线程，服务器确认请求 : Socket[addr=/127.0.0.1,port=64422,localport=9999]  
  13. 服务端接收参数 : 5 ----->向服务器端发送数据----->  
  14. 多线程，服务器确认请求 : Socket[addr=/127.0.0.1,port=64423,localport=9999]  
  15. 服务端接收参数 : 6 ----->向服务器端发送数据----->  
  16. 多线程，服务器确认请求 : Socket[addr=/127.0.0.1,port=64424,localport=9999]  
  17. 服务端接收参数 : 7 ----->向服务器端发送数据----->  
  18. 多线程，服务器确认请求 : Socket[addr=/127.0.0.1,port=64425,localport=9999]  
  19. 服务端接收参数 : 8 ----->向服务器端发送数据----->  
  20. 多线程，服务器确认请求 : Socket[addr=/127.0.0.1,port=64426,localport=9999]  
  21. 服务端接收参数 : 9 ----->向服务器端发送数据----->  
[java]   
  1. 0 向服务器端发送数据完毕，等待服务端返回数据 ... ...  
  2. 0 客户端 : <-----服务器端返回数据给客户端！<-----  
  3. 1 向服务器端发送数据完毕，等待服务端返回数据 ... ...  
  4. 1 客户端 : <-----服务器端返回数据给客户端！<-----  
  5. 2 向服务器端发送数据完毕，等待服务端返回数据 ... ...  
  6. 2 客户端 : <-----服务器端返回数据给客户端！<-----  
  7. 3 向服务器端发送数据完毕，等待服务端返回数据 ... ...  
  8. 3 客户端 : <-----服务器端返回数据给客户端！<-----  
  9. 4 向服务器端发送数据完毕，等待服务端返回数据 ... ...  
  10. 4 客户端 : <-----服务器端返回数据给客户端！<-----  
  11. 5 向服务器端发送数据完毕，等待服务端返回数据 ... ...  
  12. 5 客户端 : <-----服务器端返回数据给客户端！<-----  
  13. 6 向服务器端发送数据完毕，等待服务端返回数据 ... ...  
  14. 6 客户端 : <-----服务器端返回数据给客户端！<-----  
  15. 7 向服务器端发送数据完毕，等待服务端返回数据 ... ...  
  16. 7 客户端 : <-----服务器端返回数据给客户端！<-----  
  17. 8 向服务器端发送数据完毕，等待服务端返回数据 ... ...  
  18. 8 客户端 : <-----服务器端返回数据给客户端！<-----  
  19. 9 向服务器端发送数据完毕，等待服务端返回数据 ... ...  
  20. 9 客户端 : <-----服务器端返回数据给客户端！<-----  

1.4 BIO总结

采用BIO通信模型的服务端，通常由一个独立的Acceptor线程负责监听客户端的连接，当它接收到客户端连接请求之后，会为每个客户端创建一个新的线程进行链路处理（链路：从一个节点到相邻节点的一段物理线路，而中间没有任何其他的交换节点）。当线程处理完成后，服务端会通过输出流返回给客户端，然后线程销毁。即典型的一请求一应答通信模型。其缺点是：当客户端高并发请求，服务端不停的新建销毁线程，会增大服务器的压力。严重可能会导致服务器挂掉。后来采用线程池的方式减轻服务器的压力（这种方式被称之为：伪异步IO通信）。

2 NIO

2.1 基础理论

NIO也称New IO（官方叫法） 或者是 Non-Block IO（民间叫法）相对于传统的IO编程，NIO多出了几个概念
1）缓冲区Buffer：它是NIO与BIO的一个重要区别。BIO是将数据直接写入或读取到Stream对象中。而NIO的数据操作都是在缓冲区中进行的。而缓冲区实际上是一个数组
Buffer最常见的类型是ByteBuffer，另外还有CharBuffer，ShortBuffer，IntBuffer，LongBuffer，FloatBuffer，DoubleBuffer。常用方法在文章后面会介绍
2）通道Channel：可以理解为水管，是一个通道。和流不同，通道是双向的。NIO可以通过Channel进行数据的读，写和同时读写操作。
通道分为两大类：一类是网络读写（SelectableChannel），一类是用于文件操作（FileChannel），我们使用的SocketChannel和ServerSocketChannel都是SelectableChannel的子类。
3）多路复用器Selector：它是NIO编程的基础，非常重要。多路复用器提供选择已经就绪的任务的能力。简单说，就是Selector会不断地轮询注册在其上的通道（Channel），如果某个通道处于就绪状态（就绪状态：通道发送了读写操作），会被Selector轮询出来，然后通过SelectionKey可以取得就绪的Channel集合，从而进行后续的IO操作。
服务器端只要提供一个线程负责Selector的轮询，就可以接入成千上万个客户端，这就是JDK NIO库的巨大进步。

2.2 NIO模型图

（图片来源网络）多个客户端在多路复用器上注册，通过一个线程不停的轮询，将就绪状态的事件选择出来处理掉。

2.3 代码事例

Server端代码：
[java]   
  1. import java.io.IOException;  
  2. import java.net.InetSocketAddress;  
  3. import java.nio.ByteBuffer;  
  4. import java.nio.channels.SelectionKey;  
  5. import java.nio.channels.Selector;  
  6. import java.nio.channels.ServerSocketChannel;  
  7. import java.nio.channels.SocketChannel;  
  8. import java.util.Iterator;  
  9.   
  10. public class MyServer implements Runnable{  
  11.       
  12.     private final int BUFFER_SIZE = 1024; // 缓冲区大小  
  13.     private final int PORT = 8888; // 监听的端口  
  14.       
  15.     // 多路复用器，NIO编程的基础，负责管理通道Channel  
  16.     private Selector selector;  
  17.     // 缓冲区Buffer，和传统的BIO的一个重要区别（NIO读写数据是在缓冲区中进行，而BIO是通过流的形式）  
  18.     private ByteBuffer readBuffer = ByteBuffer.allocate(BUFFER_SIZE);  
  19.       
  20.     public MyServer() {  
  21.         startServer();  
  22.     }  
  23.   
  24.     private void startServer() {  
  25.         try {  
  26.             // 1.开启多路复用器  
  27.             selector = Selector.open();  
  28.             // 2.打开服务器通道(网络读写通道)  
  29.             ServerSocketChannel channel = ServerSocketChannel.open();  
  30.             // 3.设置服务器通道为非阻塞模式，true为阻塞，false为非阻塞  
  31.             channel.configureBlocking(false);  
  32.             // 4.绑定端口  
  33.             channel.socket().bind(new InetSocketAddress(PORT));  
  34.             // 5.把通道注册到多路复用器上，并监听阻塞事件  
  35.             /** 
  36.              * SelectionKey.OP_READ表示关注读数据就绪事件  
  37.              * SelectionKey.OP_WRITE表示关注写数据就绪事件  
  38.              * SelectionKey.OP_CONNECT表示关注socket channel的连接完成事件  
  39.              * SelectionKey.OP_ACCEPT表示关注server-socket channel的accept事件  
  40.              */  
  41.             channel.register(selector, SelectionKey.OP_ACCEPT);  
  42.             System.out.println("Server start, port :" + PORT);  
  43.         } catch (IOException e) {  
  44.             e.printStackTrace();  
  45.         }  
  46.     }  
  47.       
  48.     // 需要一个线程负责Selector的轮询  
  49.     @Override  
  50.     public void run() {  
  51.         while (true) {  
  52.             try {  
  53.                 /** 
  54.                  * a.select() 阻塞到至少有一个通道在你注册的事件上就绪  
  55.                  * b.select(long timeOut) 阻塞到至少有一个通道在你注册的事件上就绪或者超时timeOut 
  56.                  * c.selectNow() 立即返回。如果没有就绪的通道则返回0  
  57.                  * select方法的返回值表示就绪通道的个数。 
  58.                  */  
  59.                 // 1.多路复用器监听阻塞  
  60.                 selector.select();  
  61.                 // 2.多路复用器已经选择的结果集  
  62.                 Iterator<SelectionKey> selectionKeys = selector.selectedKeys().iterator();  
  63.                 // 3.不停的轮询  
  64.                 while (selectionKeys.hasNext()) {  
  65.                     // 4.获取一个选中的key  
  66.                     SelectionKey key = selectionKeys.next();  
  67.                     // 5.获取后便将其从容器中移除  
  68.                     selectionKeys.remove();  
  69.                     // 6.只获取有效的key  
  70.                     if (!key.isValid()){  
  71.                         continue;  
  72.                     }  
  73.                     // 阻塞状态处理  
  74.                     if (key.isAcceptable()){  
  75.                         accept(key);  
  76.                     }  
  77.                     // 可读状态处理  
  78.                     if (key.isReadable()){  
  79.                         read(key);  
  80.                     }  
  81.                 }  
  82.             } catch (IOException e) {  
  83.                 e.printStackTrace();  
  84.             }  
  85.         }  
  86.     }  
  87.       
  88.     // 设置阻塞，等待Client请求。在传统IO编程中，用的是ServerSocket和Socket。在NIO中采用的ServerSocketChannel和SocketChannel  
  89.     private void accept(SelectionKey selectionKey) {  
  90.         try {  
  91.             // 1.获取通道服务  
  92.             ServerSocketChannel serverSocketChannel = (ServerSocketChannel) selectionKey.channel();  
  93.             // 2.执行阻塞方法  
  94.             SocketChannel socketChannel = serverSocketChannel.accept();  
  95.             // 3.设置服务器通道为非阻塞模式，true为阻塞，false为非阻塞  
  96.             socketChannel.configureBlocking(false);  
  97.             // 4.把通道注册到多路复用器上，并设置读取标识  
  98.             socketChannel.register(selector, SelectionKey.OP_READ);  
  99.         } catch (IOException e) {  
  100.             e.printStackTrace();  
  101.         }  
  102.     }  
  103.       
  104.     private void read(SelectionKey selectionKey) {  
  105.         try {  
  106.             // 1.清空缓冲区数据  
  107.             readBuffer.clear();  
  108.             // 2.获取在多路复用器上注册的通道  
  109.             SocketChannel socketChannel = (SocketChannel) selectionKey.channel();  
  110.             // 3.读取数据，返回  
  111.             int count = socketChannel.read(readBuffer);  
  112.             // 4.返回内容为-1 表示没有数据  
  113.             if (-1 == count) {  
  114.                 selectionKey.channel().close();  
  115.                 selectionKey.cancel();  
  116.                 return ;  
  117.             }  
  118.             // 5.有数据则在读取数据前进行复位操作  
  119.             readBuffer.flip();  
  120.             // 6.根据缓冲区大小创建一个相应大小的bytes数组，用来获取值  
  121.             byte[] bytes = new byte[readBuffer.remaining()];  
  122.             // 7.接收缓冲区数据  
  123.             readBuffer.get(bytes);  
  124.             // 8.打印获取到的数据  
  125.             System.out.println("Server : " + new String(bytes)); // 不能用bytes.toString()  
  126.         } catch (IOException e) {  
  127.             e.printStackTrace();  
  128.         }  
  129.     }  
  130.       
  131.     public static void main(String[] args) {  
  132.         new Thread(new MyServer()).start();  
  133.     }  
  134.   
  135. }  
Client端：
[java]   
  1. import java.io.IOException;  
  2. import java.net.InetSocketAddress;  
  3. import java.nio.ByteBuffer;  
  4. import java.nio.channels.SocketChannel;  
  5.   
  6. public class MyClient {  
  7.       
  8.     private final static int PORT = 8888;  
  9.     private final static int BUFFER_SIZE = 1024;  
  10.     private final static String IP_ADDRESS = "127.0.0.1";  
  11.   
  12.     // 从代码中可以看出，和传统的IO编程很像，很大的区别在于数据是写入缓冲区  
  13.     public static void main(String[] args) {  
  14.         // 1.创建连接地址  
  15.         InetSocketAddress inetSocketAddress = new InetSocketAddress(IP_ADDRESS, PORT);  
  16.         // 2.声明一个连接通道  
  17.         SocketChannel socketChannel = null;  
  18.         // 3.创建一个缓冲区  
  19.         ByteBuffer byteBuffer = ByteBuffer.allocate(BUFFER_SIZE);  
  20.         try {  
  21.             // 4.打开通道  
  22.             socketChannel = SocketChannel.open();  
  23.             // 5.连接服务器  
  24.             socketChannel.connect(inetSocketAddress);  
  25.             while(true){  
  26.                 // 6.定义一个字节数组，然后使用系统录入功能：  
  27.                 byte[] bytes = new byte[BUFFER_SIZE];  
  28.                 // 7.键盘输入数据  
  29.                 System.in.read(bytes);  
  30.                 // 8.把数据放到缓冲区中  
  31.                 byteBuffer.put(bytes);  
  32.                 // 9.对缓冲区进行复位  
  33.                 byteBuffer.flip();  
  34.                 // 10.写出数据  
  35.                 socketChannel.write(byteBuffer);  
  36.                 // 11.清空缓冲区数据  
  37.                 byteBuffer.clear();  
  38.             }  
  39.         } catch (IOException e) {  
  40.             e.printStackTrace();  
  41.         } finally {  
  42.             if (null != socketChannel) {  
  43.                 try {  
  44.                     socketChannel.close();  
  45.                 } catch (IOException e) {  
  46.                     e.printStackTrace();  
  47.                 }  
  48.             }  
  49.         }  
  50.           
  51.     }  
  52. }  
以上代码只做了客户端传输数据给服务端，并没有服务端应答数据给客户端的代码。原因是：其一，后者代码逻辑和前者相似，若加上则会增大代码的理解难度。其二，NIO编程实际开发中很少用（但面试的时候经常问），更多是使用现有的框架（Netty）去完成的。
先运行MyServer类，再运行MyClient类，然后在控制台上键盘输入回车，会发现MyServer的Console控制台有打印信息。

2.4 NIO总结

NIO的本质就是为了避免原始的TCP建立连接使用三次握手的操作（），减少连接的开销。

3 AIO（NIO2.0）

3.1 基础理论

AIO 也叫NIO2.0， 在NIO的基础上
引入了新的异步通道的概念，并提供了异步文件通道和异步套接字通道的实现。从而在真正意义上实现了异步非阻塞。上面学习的NIO只是非阻塞而并非异步。而AIO它不需要通过多路复用器对注册的通道进行轮询操作即可实现异步读写，从而简化了NIO编程模型。（心里是不是有千万只草泥马奔腾而过，刚看懂NIO的多路复用器，结果AIO不用啦。其实了解NIO后会更容易理解AIO）
它的主要方法是AsynchronousServerSocketChannel 和 AsynchronousSocketChannel。
方法的命名很耿直。
从BIO的 ServerSocket和Socket，
到NIO的 ServerSocketChannel和SocketChannel，
到AIO的 AsynchronousServerSocketChannel 和 AsynchronousSocketChannel。

3.2 代码事例

Server端：
[java]   
  1. import java.net.InetSocketAddress;  
  2. import java.nio.channels.AsynchronousChannelGroup;  
  3. import java.nio.channels.AsynchronousServerSocketChannel;  
  4. import java.util.concurrent.ExecutorService;  
  5. import java.util.concurrent.Executors;  
  6.   
  7. public class MyServer {  
  8.     // 线程池  
  9.     private ExecutorService executorService;  
  10.     // 线程组  
  11.     private AsynchronousChannelGroup threadGroup;  
  12.     // 服务器通道  
  13.     public AsynchronousServerSocketChannel asynServerSocketChannel;  
  14.       
  15.     public void start(int port){  
  16.         try {  
  17.             // 1.创建一个缓存池  
  18.             executorService = Executors.newCachedThreadPool();  
  19.             // 2.创建线程组  
  20.             threadGroup = AsynchronousChannelGroup.withCachedThreadPool(executorService, 1);  
  21.             // 3.创建服务器通道  
  22.             asynServerSocketChannel = AsynchronousServerSocketChannel.open(threadGroup);  
  23.             // 4.进行绑定  
  24.             asynServerSocketChannel.bind(new InetSocketAddress(port));  
  25.             System.out.println("server start , port : " + port);  
  26.             // 5.进行阻塞  
  27.             asynServerSocketChannel.accept(this, new MyServerCompletionHandler());  
  28.             //一直阻塞 不让服务器停止，真实环境是在tomcat下运行，所以不需要这行代码  
  29.             Thread.sleep(Integer.MAX_VALUE);  
  30.               
  31.         } catch (Exception e) {  
  32.             e.printStackTrace();  
  33.         }  
  34.     }  
  35.       
  36.     public static void main(String[] args) {  
  37.         MyServer server = new MyServer();  
  38.         server.start(7777);  
  39.     }  
  40.       
  41. }  
Client端：
[java]   
  1. import java.net.InetSocketAddress;  
  2. import java.nio.ByteBuffer;  
  3. import java.nio.channels.AsynchronousSocketChannel;  
  4.   
  5. public class MyClient implements Runnable{  
  6.   
  7.     private AsynchronousSocketChannel asynSocketChannel ;  
  8.       
  9.     public MyClient() throws Exception {  
  10.         // 打开通道  
  11.         asynSocketChannel = AsynchronousSocketChannel.open();  
  12.     }  
  13.       
  14.     public void connect(){  
  15.         // 创建连接 和NIO一样  
  16.         asynSocketChannel.connect(new InetSocketAddress("127.0.0.1", 7777));  
  17.     }  
  18.       
  19.     public void write(String request){  
  20.         try {  
  21.             asynSocketChannel.write(ByteBuffer.wrap(request.getBytes())).get();  
  22.             ByteBuffer byteBuffer = ByteBuffer.allocate(1024);  
  23.             asynSocketChannel.read(byteBuffer).get();  
  24.             byteBuffer.flip();  
  25.             byte[] respByte = new byte[byteBuffer.remaining()];  
  26.             byteBuffer.get(respByte); // 将缓冲区的数据放入到 byte数组中  
  27.             System.out.println(new String(respByte,"utf-8").trim());  
  28.         } catch (Exception e) {  
  29.             e.printStackTrace();  
  30.         }  
  31.     }  
  32.   
  33.     @Override  
  34.     public void run() {  
  35.         while(true){  
  36.               
  37.         }  
  38.     }  
  39.       
  40.     // 模拟三个客户端请求  
  41.     public static void main(String[] args) throws Exception {  
  42.         MyClient myClient1 = new MyClient();  
  43.         myClient1.connect();  
  44.         MyClient myClient2 = new MyClient();  
  45.         myClient2.connect();  
  46.         MyClient myClient3 = new MyClient();  
  47.         myClient3.connect();  
  48.           
  49.         new Thread(myClient1, "myClient1").start();  
  50.         new Thread(myClient2, "myClient2").start();  
  51.         new Thread(myClient3, "myClient3").start();  
  52.           
  53.         Thread.sleep(1000);  
  54.           
  55.         myClient1.write("myClient1 BIO");  
  56.         myClient2.write("myClient2 NIO");  
  57.         myClient3.write("myClient3 AIO");  
  58.     }  
  59.       
  60. }  
ServerHandler：
[java]   
  1. import java.nio.ByteBuffer;  
  2. import java.nio.channels.AsynchronousSocketChannel;  
  3. import java.nio.channels.CompletionHandler;  
  4. import java.util.concurrent.ExecutionException;  
  5.   
  6. public class MyServerCompletionHandler implements CompletionHandler<AsynchronousSocketChannel, MyServer> {  
  7.       
  8.     private final int BUFFER_SIZE = 1024;  
  9.   
  10.     @Override  
  11.     public void completed(AsynchronousSocketChannel asynSocketChannel, MyServer attachment) {  
  12.         //当有下一个客户端接入的时候 直接调用Server的accept方法，这样反复执行下去，保证多个客户端都可以阻塞  
  13.         attachment.asynServerSocketChannel.accept(attachment, this);  
  14.         read(asynSocketChannel);  
  15.     }  
  16.   
  17.     private void read(final AsynchronousSocketChannel asynSocketChannel) {  
  18.         //读取数据  
  19.         ByteBuffer byteBuffer = ByteBuffer.allocate(BUFFER_SIZE);  
  20.         asynSocketChannel.read(byteBuffer, byteBuffer, new CompletionHandler<Integer, ByteBuffer>() {  
  21.             @Override  
  22.             public void completed(Integer resultSize, ByteBuffer attachment) {  
  23.                 //进行读取之后,重置标识位  
  24.                 attachment.flip();  
  25.                 //获得读取的字节数  
  26.                 System.out.println("Server -> " + "收到客户端的数据长度为:" + resultSize);  
  27.                 //获取读取的数据  
  28.                 String resultData = new String(attachment.array()).trim();  
  29.                 System.out.println("Server -> " + "收到客户端的数据信息为:" + resultData);  
  30.                 String response = "服务器响应, 收到了客户端发来的数据: " + resultData;  
  31.                 write(asynSocketChannel, response);  
  32.             }  
  33.             @Override  
  34.             public void failed(Throwable exc, ByteBuffer attachment) {  
  35.                 exc.printStackTrace();  
  36.             }  
  37.         });  
  38.     }  
  39.       
  40.     private void write(AsynchronousSocketChannel asynSocketChannel, String response) {  
  41.         try {  
  42.             // 把数据写入到缓冲区中  
  43.             ByteBuffer buf = ByteBuffer.allocate(BUFFER_SIZE);  
  44.             buf.put(response.getBytes());  
  45.             buf.flip();  
  46.             // 在从缓冲区写入到通道中  
  47.             asynSocketChannel.write(buf).get();  
  48.         } catch (InterruptedException e) {  
  49.             e.printStackTrace();  
  50.         } catch (ExecutionException e) {  
  51.             e.printStackTrace();  
  52.         }  
  53.     }  
  54.       
  55.     @Override  
  56.     public void failed(Throwable exc, MyServer attachment) {  
  57.         exc.printStackTrace();  
  58.     }  
  59.   
  60. }  
打印结果：
[java]   
  1. server start , port : 7777  
  2. Server -> 收到客户端的数据长度为:13  
  3. Server -> 收到客户端的数据信息为:myClient1 BIO  
  4. Server -> 收到客户端的数据长度为:13  
  5. Server -> 收到客户端的数据信息为:myClient2 NIO  
  6. Server -> 收到客户端的数据长度为:13  
  7. Server -> 收到客户端的数据信息为:myClient3 AIO  
[java]   
  1. 服务器响应, 收到了客户端发来的数据: myClient1 BIO  
  2. 服务器响应, 收到了客户端发来的数据: myClient2 NIO  
  3. 服务器响应, 收到了客户端发来的数据: myClient3 AIO  

4 Buffer常用方法

取值前先复位，position位置很重要。
[java]   
  1. import java.nio.IntBuffer;  
  2.   
  3. public class TestBuffer {  
  4.       
  5.     public static void main(String[] args) {  
  6.           
  7.         // 1 基本操作  
  8.         //创建指定长度的缓冲区  
  9.         IntBuffer buf = IntBuffer.allocate(10);  
  10.         buf.clear();// 每次执行清空一下   
  11.         buf.put(13);// position位置：0 - > 1 位置，下一个要被读或写的元素的索引，每次读写缓冲区数据时都会改变改值，为下次读写作准备  
  12.         buf.put(21);// position位置：1 - > 2  
  13.         buf.put(35);// position位置：2 - > 3  
  14.         System.out.println("不使用flip复位：" + buf);  
  15.         System.out.println(buf.get()); // 相对读，从position位置读取一个byte，并将position+1，为下次读写作准备 3 - > 4  
  16.         System.out.println(buf.get()); // 4 - > 5  
  17.         System.out.println(buf.get()); // 5 - > 6  
  18.         //把位置复位为0，也就是position位置：3 - > 0  
  19.         buf.flip();  
  20.         System.out.println("使用flip复位：" + buf);  
  21.         System.out.println(buf.get());  
  22.         System.out.println(buf.get());  
  23.         System.out.println(buf.get());  
  24.         System.out.println("获取下标为1的元素：" + buf.get(1) + "\t get(index)方法，position位置不改变：" + buf.position());  
  25.         buf.put(1, 4);  
  26.         System.out.println("获取下标为1的元素：" + buf.get(1) + "\t put(index, change)方法，position位置不变：" + buf);  
  27.           
  28.         System.out.println("\n=============================================\n");  
  29.         /* 
  30.         // 2 wrap方法使用 
  31.         //  wrap方法会包裹一个数组: 一般这种用法不会先初始化缓存对象的长度，因为没有意义，最后还会被wrap所包裹的数组覆盖掉。  
  32.         //  并且wrap方法修改缓冲区对象的时候，数组本身也会跟着发生变化。                      
  33.         int[] arr = new int[]{1,2,5}; 
  34.         IntBuffer buf1 = IntBuffer.wrap(arr); 
  35.         System.out.println(buf1); 
  36.          
  37.         IntBuffer buf2 = IntBuffer.wrap(arr, 0 , 2); 
  38.         //这样使用表示容量为数组arr的长度，但是可操作的元素只有实际进入缓存区的元素长度 
  39.         System.out.println(buf2); 
  40.         */  
  41.           
  42.         // 3 其他方法  
  43.         IntBuffer buf1 = IntBuffer.allocate(10);  
  44.         int[] arr = new int[]{
    1,2,5};  
  45.         buf1.put(arr);  
  46.         System.out.println(buf1);  
  47.         //一种复制方法  
  48.         IntBuffer buf3 = buf1.duplicate();  
  49.         System.out.println(buf3);  
  50.           
  51.         //设置buf1的位置属性  
  52.         buf1.flip();  
  53.         System.out.println(buf1);  
  54.         System.out.println("可读数据为：" + buf1.remaining());  
  55.           
  56.         int[] arr2 = new int[buf1.remaining()];  
  57.         //将缓冲区数据放入arr2数组中去  
  58.         buf1.get(arr2);  
  59.         for(int i : arr2){  
  60.             System.out.print(Integer.toString(i) + ",");  
  61.         }  
  62.           
  63.     }  
  64. }  

5 优质博客

以上便是BIO，NIO，AIO相关笔记，虽然实际开发中很少使用，但面试的时候经常遇到
你可能感兴趣的文章
驱动开发误用指针错误：Unable to handle kernel NULL pointer dereference at virtual address
查看>>
Linux部署DocSystem知识/文件管理系统
查看>>
Centos7开机自启动脚本无法使用备用方案
查看>>
jvm虚拟机内存详解
查看>>
线程的创建方式
查看>>
DNS是什么
查看>>
mapreduce自定义分组、自定义分区、二次排序
查看>>
Hbase架构
查看>>
spark运行模式
查看>>
PaddleX的C++使用
查看>>
MyBatis-Plus代码生成器
查看>>
我的第一个SpringBoot项目(一)
查看>>
回文数
查看>>
伪背包问题！
查看>>
求10000以内n的阶乘！
查看>>
static关键字
查看>>
类的继承
查看>>
final关键字
查看>>
抽象类
查看>>
java的多态现象
查看>>
喝酒易醉，品茶养心，人生如梦，品茶悟道，何以解忧？唯有杜康！-- 愿君每日到此一游！
当前时间: 2024-09-12 22:55:09   当前IP: 3.21.247.208   联系邮箱:javaeecc@qq.com     Copyright © 2020 - 2022 baihongyu.com 京ICP备2021015314号-2
强烈建议你试试无所不能的CHAT-GPT，快点击我
强烈建议你试试无所不能的CHAT-GPT，快点击我