网络IO模型简介

一、基础知识点

1、同步、异步、阻塞、非阻塞

  提供一种从网络IO角度的理解。

同步：由程序自己去完成实际的IO。在linux系统中的网络IO，最终读写数据都是通过程序自己通过系统调用read和write实现的，所以是同步的。

异步：由内核完成IO再告诉程序结果。也就是进程发起一个IO操作之后就继续执行下面的代码，内核去完成这个IO操作，完成之后通知进程。

阻塞：线程在调用结果返回之前会被挂起，拿到结果才会继续执行

非阻塞：当前线程不用等到调用结果返回，可以直接继续执行

2、TCP连接

2.1 建立连接3次握手

• 客户端发送SYN请求连接
• 服务端监听着端口，收到请求报文后，如同意连接，针对客户端SYN向客户端发送确认ACK，以及一个SYN。
  • 这个SYN是要确定客户端是否准备好接收数据
• 客户端收到ACK和SYN后，针对服务端SYN再发送一个ACK

2.2 断开连接4次挥手

• 客户端准备号要断开连接后向服务端发送断开请求FIN
• 服务端收到FIN后，给客户端发送ACK
  • 这里发送完之后，服务端开始准备断开请求，处理完自己这边的事情
• 服务端经过一个等待，确定可以关闭连接后，发送FIN
• 客户端收到FIN，处理完自己这边的事情后发送ACK

二、网络IO发展过程

１、BIO(Blocking IO)

  客户端首先会创建一个server socket，并监听着一个端口。之后在一个死循环中用accept方法接收客户端的连接请求。如果没有连接请求过来，那么accept方法会一直阻塞。
  当有连接请求进来时，服务端会根据两边的IP和端口号生成一个用于两端IO的socket，接着新起一个线程在这个线程里面对这个连接进行IO。
  这种模型里，accept，read，write都是同步阻塞的。
  下面是客户端代码。

public class SocketBIO {
    public static void main(String[] args) throws Exception {
        // 客户端创建server socket，监听9090端口
        ServerSocket server = new ServerSocket(9090,20); 

        while (true) {
            Socket client = server.accept();  //阻塞1

            new Thread(new Runnable(){

                public void run() {
                    InputStream in = null;
                    try {
                        in = client.getInputStream();
                        BufferedReader reader = new BufferedReader(new InputStreamReader(in));
                        while(true){
                            String dataline = reader.readLine(); //阻塞2

                            if(null != dataline){
                                System.out.println(dataline);
                            }else{
                                client.close();
                                break;
                            }
                        }
                        System.out.println("客户端断开");
                    } catch (IOException e) {
                        e.printStackTrace();
                    }

                }
            }).start();
        }
    }
}

1.1 客户端过多

  因为每当建立了新请求，服务端就会新起一个线程。当连接数超过10万，就需要新起10万个线程去完成网络IO。大量的线程的调度会占用大量的CPU资源。
  BIO的问题就在于阻塞，因为阻塞，所以为了在处理数据的时候还能接收新的连接请求，不得不新起线程去处理数据。

2、NIO

  同BIO相比，NIO中的accept，read，write都是非阻塞的。这样即使当前连接没有数据发送到服务端，服务端也不会在read处阻塞住等待数据过来。就可以再接收新的连接请求。
  为了可以接收每一个连接的数据，所以会用一个list存放每一个连接的socket，之后在一个死循环中，不断遍历每一个连接，当有数据过来时，就进行IO操作。

public static void main(String[] args) throws Exception {

        LinkedList<SocketChannel> clients = new LinkedList<>();

        //服务端创建server socket，监听9090端口，并将accept设置为非阻塞
        ServerSocketChannel ss = ServerSocketChannel.open();  
        ss.bind(new InetSocketAddress(9090));
        ss.configureBlocking(false); 

        while (true) {
            //接受客户端的连接
            SocketChannel client = ss.accept(); 
            
            if (client == null) {
            	// 没有连接请求不处理
            } else {
                // 可以给客户端连接设置为noblocking，这样下面在read的时候也不会阻塞
                client.configureBlocking(false); 
                int port = client.socket().getPort();
                clients.add(client);
            }

            // new io中的bytebuffer
            ByteBuffer buffer = ByteBuffer.allocateDirect(4096); 

            //遍历已经链接进来的客户端能不能读写数据。当线程很多的时候，这个遍历的时间是很长的，并且每一次都会调用一次read
            for (SocketChannel c : clients) {  
               
                int num = c.read(buffer); 
                if (num > 0) {
                    buffer.flip();
                    byte[] aaa = new byte[buffer.limit()];
                    buffer.get(aaa);

                    String b = new String(aaa);
                    System.out.println(c.socket().getPort() + " : " + b);
                    buffer.clear();
                }
            }
        }
    }

2.1 NIO的弊端

  用单个线程去接收，然后遍历所有连接，对有数据的连接进行IO操作。而每一次IO操作都会系统调用read，如果有10万个连接时，一次遍历中，进程就要完成10万次从用户态到内核态的切换，这对资源的消耗也是巨大的。

3、多路复用器

  NIO的弊端在于遍历连接产生了大量无效的系统调用（没有数据的连接也会进行一次系统调用），如果能通过一次系统调用就知道哪些连接有数据过来就可以解决NIO的问题，这就是多用复用器产生的原因。

3.1 SELECT 和 POLL模式

  这两种多路复用器的原理差不多，使用它们之后，程序只需要通过一个select系统调用，然后由内核去完成连接的遍历，最后再将有数据的连接返回给程序。程序在根据返回的结果去一个个调用read系统调用读取数据。这样就可以大大减少不必要的系统调用。

3.2 EPOLL模式

  上面两种多路复用器的弊端在于内核每次都要从头开始遍历每一个连接。为了解决这个问题，就诞生了epoll。在程序中，如果使用了epoll，那么一开始就会在内核中为epoll申请一块空间，这块空间是为了放一颗红黑树。当有新的连接建立时，就会在红黑树中插入一个节点表示这个连接。当某个连接有数据过来了，会启动中断处理程序，将网卡中的数据存入内核中，epoll会在这之后将此连接的节点加入到一个链表中，这个链表就是所有有数据的连接集合。这样当程序调用epoll系统调用时，就会直接返回这个链表。这样就避免了从头开始遍历。

4、异步IO

  多路复用器模式中，每一次程序都要先用一次系统调用找出哪些连接有数据，然后再分别调用系统调用read去读数据。如果程序可以完全将IO交给内核去完成，即程序只用一个系统调用read，接下来的事情全都交给内核，内核完成数据读取后，将数据复制到程序的空间。这就是异步IO。