BIO编程及实现代码

喜欢ヅ旅行 2022-06-08 09:47 304阅读 0赞

## BIO编程    ##

###     1.1、传统的BIO编程 ###

网络编程的基本模型是C/S模型，即两个进程间的通信。

服务端提供IP和监听端口，客户端通过连接操作想服务端监听的地址发起连接请求，通过三次握手连接，如果连接成功建立，双方就可以通过套接字进行通信。

传统的同步阻塞模型开发中，ServerSocket负责绑定IP地址，启动监听端口；Socket负责发起连接操作。连接成功后，双方通过输入和输出流进行同步阻塞式通信。

简单的描述一下BIO的服务端通信模型：采用BIO通信模型的服务端，通常由一个独立的Acceptor线程负责监听客户端的连接，它接收到客户端连接请求之后为每个客户端创建一个新的线程进行链路处理没处理完成后，通过输出流返回应答给客户端，线程销毁。即典型的一请求一应答通宵模型。

传统BIO通信模型图：

![01][]

该模型最大的问题就是缺乏弹性伸缩能力，当客户端并发访问量增加后，服务端的线程个数和客户端并发访问数呈1:1的正比关系，Java中的线程也是比较宝贵的系统资源，线程数量快速膨胀后，系统的性能将急剧下降，随着访问量的继续增大，系统最终就**死-掉-了**。

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

**客户端消息处理线程ServerHandler源码：**

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

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

1.  ***package** com.anxpp.io.calculator.bio;  *
2.  ***import** java.io.BufferedReader;  *
3.  ***import** java.io.IOException;  *
4.  ***import** java.io.InputStreamReader;  *
5.  ***import** java.io.PrintWriter;  *
6.  ***import** java.net.Socket;  *
7.  *  *
8.  ***import** com.anxpp.io.utils.Calculator;  *
9.  */\*\* *
10. * \* 客户端线程 *
11. * \* @author yangtao\_\_anxpp.com *
12. * \* 用于处理一个客户端的Socket链路 *
13. * \*/  *
14. ***public** **class** ServerHandler **implements** Runnable\{  *
15. *    **private** Socket socket;  *
16. *    **public** ServerHandler(Socket socket) \{  *
17. *        **this**.socket = socket;  *
18. *    \}  *
19. *    @Override  *
20. *    **public** **void** run() \{  *
21. *        BufferedReader in = **null**;  *
22. *        PrintWriter out = **null**;  *
23. *        **try**\{  *
24. *            in = **new** BufferedReader(**new** InputStreamReader(socket.getInputStream()));  *
25. *            out = **new** PrintWriter(socket.getOutputStream(),**true**);  *
26. *            String expression;  *
27. *            String result;  *
28. *            **while**(**true**)\{  *
29. *                //通过BufferedReader读取一行  *
30. *                //如果已经读到输入流尾部，返回null,退出循环  *
31. *                //如果得到非空值，就尝试计算结果并返回  *
32. *                **if**((expression = in.readLine())==**null**) **break**;  *
33. *                System.out.println("服务器收到消息：" + expression);  *
34. *                **try**\{  *
35. *                    result = Calculator.cal(expression).toString();  *
36. *                \}**catch**(Exception e)\{  *
37. *                    result = "计算错误：" + e.getMessage();  *
38. *                \}  *
39. *                out.println(result);  *
40. *            \}  *
41. *        \}**catch**(Exception e)\{  *
42. *            e.printStackTrace();  *
43. *        \}**finally**\{  *
44. *            //一些必要的清理工作  *
45. *            **if**(in != **null**)\{  *
46. *                **try** \{  *
47. *                    in.close();  *
48. *                \} **catch** (IOException e) \{  *
49. *                    e.printStackTrace();  *
50. *                \}  *
51. *                in = **null**;  *
52. *            \}  *
53. *            **if**(out != **null**)\{  *
54. *                out.close();  *
55. *                out = **null**;  *
56. *            \}  *
57. *            **if**(socket != **null**)\{  *
58. *                **try** \{  *
59. *                    socket.close();  *
60. *                \} **catch** (IOException e) \{  *
61. *                    e.printStackTrace();  *
62. *                \}  *
63. *                socket = **null**;  *
64. *            \}  *
65. *        \}  *
66. *    \}  *
67. *\}  *

**同步阻塞式I/O创建的Client源码：**

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

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

1.  ***package** com.anxpp.io.calculator.bio;  *
2.  ***import** java.io.BufferedReader;  *
3.  ***import** java.io.IOException;  *
4.  ***import** java.io.InputStreamReader;  *
5.  ***import** java.io.PrintWriter;  *
6.  ***import** java.net.Socket;  *
7.  */\*\* *
8.  * \* 阻塞式I/O创建的客户端 *
9.  * \* @author yangtao\_\_anxpp.com *
10. * \* @version 1.0 *
11. * \*/  *
12. ***public** **class** Client \{  *
13. *    //默认的端口号  *
14. *    **private** **static** **int** DEFAULT\_SERVER\_PORT = 12345;  *
15. *    **private** **static** String DEFAULT\_SERVER\_IP = "127.0.0.1";  *
16. *    **public** **static** **void** send(String expression)\{  *
17. *        send(DEFAULT\_SERVER\_PORT,expression);  *
18. *    \}  *
19. *    **public** **static** **void** send(**int** port,String expression)\{  *
20. *        System.out.println("算术表达式为：" + expression);  *
21. *        Socket socket = **null**;  *
22. *        BufferedReader in = **null**;  *
23. *        PrintWriter out = **null**;  *
24. *        **try**\{  *
25. *            socket = **new** Socket(DEFAULT\_SERVER\_IP,port);  *
26. *            in = **new** BufferedReader(**new** InputStreamReader(socket.getInputStream()));  *
27. *            out = **new** PrintWriter(socket.getOutputStream(),**true**);  *
28. *            out.println(expression);  *
29. *            System.out.println("\_\_\_结果为：" + in.readLine());  *
30. *        \}**catch**(Exception e)\{  *
31. *            e.printStackTrace();  *
32. *        \}**finally**\{  *
33. *            //一下必要的清理工作  *
34. *            **if**(in != **null**)\{  *
35. *                **try** \{  *
36. *                    in.close();  *
37. *                \} **catch** (IOException e) \{  *
38. *                    e.printStackTrace();  *
39. *                \}  *
40. *                in = **null**;  *
41. *            \}  *
42. *            **if**(out != **null**)\{  *
43. *                out.close();  *
44. *                out = **null**;  *
45. *            \}  *
46. *            **if**(socket != **null**)\{  *
47. *                **try** \{  *
48. *                    socket.close();  *
49. *                \} **catch** (IOException e) \{  *
50. *                    e.printStackTrace();  *
51. *                \}  *
52. *                socket = **null**;  *
53. *            \}  *
54. *        \}  *
55. *    \}  *
56. *\}  *

测试代码，为了方便在控制台看输出结果，放到同一个程序（jvm）中运行：

**\[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.util.Random;  *
4.  */\*\* *
5.  * \* 测试方法 *
6.  * \* @author yangtao\_\_anxpp.com *
7.  * \* @version 1.0 *
8.  * \*/  *
9.  ***public** **class** Test \{  *
10. *    //测试主方法  *
11. *    **public** **static** **void** main(String\[\] args) **throws** InterruptedException \{  *
12. *        //运行服务器  *
13. *        **new** Thread(**new** Runnable() \{  *
14. *            @Override  *
15. *            **public** **void** run() \{  *
16. *                **try** \{  *
17. *                    ServerBetter.start();  *
18. *                \} **catch** (IOException e) \{  *
19. *                    e.printStackTrace();  *
20. *                \}  *
21. *            \}  *
22. *        \}).start();  *
23. *        //避免客户端先于服务器启动前执行代码  *
24. *        Thread.sleep(100);  *
25. *        //运行客户端   *
26. *        **char** operators\[\] = \{ '+','-','\*','/'\};  *
27. *        Random random = **new** Random(System.currentTimeMillis());  *
28. *        **new** Thread(**new** Runnable() \{  *
29. *            @SuppressWarnings("static-access")  *
30. *            @Override  *
31. *            **public** **void** run() \{  *
32. *                **while**(**true**)\{  *
33. *                    //随机产生算术表达式  *
34. *                    String expression = random.nextInt(10)+""\+operators\[random.nextInt(4)\]+(random.nextInt(10)+1);  *
35. *                    Client.send(expression);  *
36. *                    **try** \{  *
37. *                        Thread.currentThread().sleep(random.nextInt(1000));  *
38. *                    \} **catch** (InterruptedException e) \{  *
39. *                        e.printStackTrace();  *
40. *                    \}  *
41. *                \}  *
42. *            \}  *
43. *        \}).start();  *
44. *    \}  *
45. *\}  *

其中一次的运行结果：

1.  服务器已启动，端口号：12345
2.  算术表达式为：4\-2
3.  服务器收到消息：4\-2
4.  \_\_\_结果为：2
5.  算术表达式为：5\-10
6.  服务器收到消息：5\-10
7.  \_\_\_结果为：-5
8.  算术表达式为：0\-9
9.  服务器收到消息：0\-9
10. \_\_\_结果为：-9
11. 算术表达式为：0\+6
12. 服务器收到消息：0\+6
13. \_\_\_结果为：6
14. 算术表达式为：1/6
15. 服务器收到消息：1/6
16. \_\_\_结果为：0.16666666666666666
17. *...*

从以上代码，很容易看出，BIO主要的问题在于每当有一个新的客户端请求接入时，服务端必须创建一个新的线程来处理这条链路，在需要满足高性能、高并发的场景是没法应用的（大量创建新的线程会严重影响服务器性能，甚至罢工）。

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