本文阐述了socket编程、IO网络模型，以及各种IO模型的适用场景。

RPC架构设计

文章更新历史

2022/03/01 初稿。

2022/05/04 修改相关描述。

socket

socket网络编程

socket概述

socket套接字是两台主机之间逻辑连接的端点。

TCP/IP协议是传输层协议，主要解决数据在网络中的传输

socket是网络通信之间的抽象接口，它包含网络通信的五种基础信息：连接使用的协议、本地主机的ip地址、本地进程协议端口、远程主机ip地址、远程进程的协议端口。

socket整体流程

socket编程主要包括客户端和服务端两个方面。

首先在服务端创建一个服务端套接字（ServerSocket），并把它附加到一个端口上，服务端从这个端口监听链接。

端口范围是 0-65536 ，注意 0-1024 是特权服务保留的端口。可选择任意一个不被其他进程使用的端口。

客户端请求与服务端连接时，根据服务端的域名或者ip地址，加上端口号，打开一个套接字。当服务器接受连接后，服务器和客户端之间的操作可以像输入输出流一样操作。

代码实现

1. 服务端代码

   /**
    * 服务端
    *
    * @name: ServerDemo
    * @author: terwer
    * @date: 2022-04-17 14:20
    **/
   public class ServerDemo {
       public static void main(String[] args) throws IOException {
           // 1.创建一个线程池，如果有客户端链接就创建一个线程与之通信
           ExecutorService executorService = Executors.newCachedThreadPool();
           // 2.创建ServerSocket
           ServerSocket serverSocket = new ServerSocket(9999);
           System.out.println("服务器已启动");
           while (true) {
               // 3.监听客户端
               Socket socket = serverSocket.accept();
               System.out.println("有客户端链接");
               executorService.execute(new Runnable() {
                   @Override
                   public void run() {
                       handle(socket);
                   }
               });
           }
       }
   
       private static void handle(Socket socket) {
           try {
               System.out.println("线程ID:" + Thread.currentThread().getId() + ",线程名称：" + Thread.currentThread().getName());
               // 从连接中取出输入流
               InputStream inputStream = socket.getInputStream();
               byte[] b = new byte[1024];
               int read = inputStream.read(b);
               System.out.println("客户端" + new String(b, 0, read));
   
               // 链接中取出输出流并回话
               OutputStream outputStream = socket.getOutputStream();
               outputStream.write("没有".getBytes());
           } catch (Exception e) {
               e.printStackTrace();
           } finally {
               try {
                   socket.close();
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
       }
   }
   

2. 客户端代码

   /**
    * 客户端
    *
    * @name: ClientDemo
    * @author: terwer
    * @date: 2022-04-17 15:30
    **/
   public class ClientDemo {
       public static void main(String[] args) throws IOException {
           while (true) {
               // 1.创建客户端socket
               Socket s = new Socket("127.0.0.1", 9999);
               // 2.从连接中获取输出流并发送消息
               OutputStream os = s.getOutputStream();
               System.out.println("请输入:");
               Scanner sc = new Scanner(System.in);
               String msg = sc.nextLine();
               os.write(msg.getBytes());
   
               // 3.从连接中取出输入流并接受会话
               InputStream is = s.getInputStream();
               byte[] b = new byte[1024];
               // 下面写法错了
               // int read = is.read();
               // 应该是
               int read = is.read(b);
               System.out.println("老板说:" + new String(b, 0, read).trim());
   
               s.close();
           }
       }
   }
   

IO模型

IO模型说明

1. 简单理解：用什么样的通道进行数据的发送和接收。在很大程度上决定了程序通信的性能。

2. Java支持三种网络编程模型I/O模式：BIO（同步阻塞）、NIO（同步非阻塞）、AIO（异步非阻塞）

   阻塞与非阻塞

   指的是网络IO的线程是否处于阻塞或者等待状态

   线程访问资源，该资源是否准备就绪的一种处理方式

   

   同步和异步

   指的是数据的请求方式，同步和异步是请求数据的一种方式。

   

BIO（同步阻塞）

Java BIO就是传统的socket编程

BIO（blocking IO）：同步阻塞，服务器实现方式为一个链接一个线程，即客户端有一个链接时，服务端就要启动一个线程进行处理，如果这个链接不作任何事情，会造成不必要的线程开销，可以通过线程池改善，实现多个客户端链接服务器。

工作机制

生活中的例子：

BIO的问题分析

1. 每个请求都要创建独立的线程，与对应的客户端进行read，业务处理，数据write
2. 并发量大的时候，需要创建大量的线程来处理链接，系统资源占用较大
3. 链接建立后，如果当前线程没有数据可读，线程就阻塞在read上，造成线程资源浪费

NIO（同步非阻塞）

同步非阻塞，服务器实现模式为一个线程处理多个请求（链接），客户端发送的链接请求会注册到多路复用器上，多路复用器轮训到链接有IO请求就进行处理。

生活中的例子：

AIO（异步非阻塞）

AIO引入了异步通道的概念，采用了Proactor模式，简化了程序编写，有效的请求才启动线程。

他的特点是先由操作系统完成后才通知服务端启动线程去处理，一般适用于连接数较多且连接时间较长的应用。

Proactor模式是一个消息异步通知的模式，Proactor通知的不是就绪事件，而是操作完成事件，这也是操作系统异步IO的主要模型。

https://www.zhihu.com/question/26943938

生活中的例子：

BIO、NIO、AIO的适用场景分析

1. BIO（同步阻塞模式）适用于连接数比较小，且固定的架构。对服务器资源的要求比较高，并发局限于应用中，jdk1.4以前的唯一选择，代码容易理解。
2. NIO（同步非阻塞模式）适用于链接数目多且链接比较短（轻操作）的架构，比如聊天服务器、弹幕系统、服务器之间的通讯等。编程比较复杂，jdk1.4开始支持。
3. AIO（异步非阻塞模式）适用于连接数目比较多并且连接时间比较长（重操作）的架构，比如相册服务器，充分调用OS参与并发操作。编程比较复杂，jdk1.7开始支持。