伪异步I/O编程及代码实现

桃扇骨 2022-06-08 09:47 228阅读 0赞

### 伪异步I/O编程 ###

为了改进这种一连接一线程的模型，我们可以使用线程池来管理这些线程（需要了解更多请参考前面提供的文章），实现1个或多个线程处理N个客户端的模型（但是底层还是使用的同步阻塞I/O），通常被称为“伪异步I/O模型“。

伪异步I/O模型图：

![02][]

实现很简单，我们只需要将新建线程的地方，交给线程池管理即可，只需要改动刚刚的**Server**代码即可：

**\[java\]** [view plain][] [copy][view plain]

[print][view plain][?][view plain]

1.  **package** com.anxpp.io.calculator.bio;  
2.  **import** java.io.IOException;  
3.  **import** java.net.ServerSocket;  
4.  **import** java.net.Socket;  
5.  **import** java.util.concurrent.ExecutorService;  
6.  **import** java.util.concurrent.Executors;  
7.  /\*\* 
8.   \* BIO服务端源码\_\_伪异步I/O 
9.   \* @author yangtao\_\_anxpp.com 
10.  \* @version 1.0 
11.  \*/  
12. **public** **final** **class** ServerBetter \{  
13.     //默认的端口号  
14.     **private** **static** **int** DEFAULT\_PORT = 12345;  
15.     //单例的ServerSocket  
16.     **private** **static** ServerSocket server;  
17.     //线程池 懒汉式的单例  
18.     **private** **static** ExecutorService executorService = Executors.newFixedThreadPool(60);  
19.     //根据传入参数设置监听端口，如果没有参数调用以下方法并使用默认值  
20.     **public** **static** **void** start() **throws** IOException\{  
21.         //使用默认值  
22.         start(DEFAULT\_PORT);  
23.     \}  
24.     //这个方法不会被大量并发访问，不太需要考虑效率，直接进行方法同步就行了  
25.     **public** **synchronized** **static** **void** start(**int** port) **throws** IOException\{  
26.         **if**(server != **null**) **return**;  
27.         **try**\{  
28.             //通过构造函数创建ServerSocket  
29.             //如果端口合法且空闲，服务端就监听成功  
30.             server = **new** ServerSocket(port);  
31.             System.out.println("服务器已启动，端口号：" + port);  
32.             //通过无线循环监听客户端连接  
33.             //如果没有客户端接入，将阻塞在accept操作上。  
34.             **while**(**true**)\{  
35.                 Socket socket = server.accept();  
36.                 //当有新的客户端接入时，会执行下面的代码  
37.                 //然后创建一个新的线程处理这条Socket链路  
38.                 executorService.execute(**new** ServerHandler(socket));  
39.             \}  
40.         \}**finally**\{  
41.             //一些必要的清理工作  
42.             **if**(server != **null**)\{  
43.                 System.out.println("服务器已关闭。");  
44.                 server.close();  
45.                 server = **null**;  
46.             \}  
47.         \}  
48.     \}  
49. \}

测试运行结果是一样的。

我们知道，如果使用CachedThreadPool线程池（不限制线程数量，如果不清楚请参考文首提供的文章），其实除了能自动帮我们管理线程（复用），看起来也就像是1:1的客户端：线程数模型，而使用FixedThreadPool我们就有效的控制了线程的最大数量，保证了系统有限的资源的控制，实现了N:M的伪异步I/O模型。

但是，正因为限制了线程数量，如果发生大量并发请求，超过最大数量的线程就只能等待，直到线程池中的有空闲的线程可以被复用。而对Socket的输入流就行读取时，会一直阻塞，直到发生：

*      有数据可读
 *      可用数据以及读取完毕
 *      发生空指针或I/O异常

所以在读取数据较慢时（比如数据量大、网络传输慢等），大量并发的情况下，其他接入的消息，只能一直等待，这就是最大的弊端。

而后面即将介绍的NIO，就能解决这个难题。

[02]: http://blog.anxpp.com/usr/uploads/2016/05/614169023.png
[view plain]: http://blog.csdn.net/anxpp/article/details/51512200#