网络IO

阻塞模型

在之前网络通信都是阻塞模型

客户端向服务端发出请求后，客户端会一直处于等待状态，直到服务器端返回结果或网络出现问题
服务器端也是如此，在处理某个客户端A发来的请求时，另一个客户端B发来的请求会等待，直到服务器端的处理线程线程上一个请求的处理

在服务端使用ServerSocket来建立套接字，accept方法会进行阻塞等待客户端的连接

try(
        // 创建一个ServerSocket对象
        ServerSocket serverSocket = new ServerSocket(9090);
        // accept方法，返回Socket对象，这里会进行阻塞，应用程序向操作系统请求接收已准备好的客户端连接的数据信息
        Socket s = serverSocket.accept();
        // 获取输入流，这里读取数据也会阻塞
        InputStream is = s.getInputStream();
        // 输出流，给客户端返回消息
        OutputStream os = s.getOutputStream();
        InputStreamReader isr = new InputStreamReader(is);
        BufferedReader reader = new BufferedReader(isr);
){
    String str;
    while ((str = reader.readLine()) != null){
        System.out.print(str);
    }
    os.write("我已收到消息".getBytes());
    
} catch (IOException e){
    e.printStackTrace();
}

serverSocket.accept()阻塞

服务器端发起一个accept动作，询问操作系统是否有新的Socket套接字信息从端口发送过来，如果没有则serverSocket.accept()会一直等待

阻塞模型的问题：

同一时间，服务器只能接收一个客户端的请求信息，第二个客户端需要等待服务器接收完第一个请求数据后才会被接收
服务器一次只能处理一个客户端请求，处理完成并返回后才能进行第二次请求的处理

多线程阻塞模型

由于阻塞模型的弊端，高并发时会导致请求太慢，所以提出了使用多线程来解决上述阻塞问题

服务器收到客户端A的请求后，开启线程去进行数据处理。主线程可以继续接收客户端B的请求

但是这样在进行serverSocket.accept();操作时还是单线程运行，只有业务处理才会使用多线程，对于接收数据的并发能力并没有提升

同步非阻塞模型

这里先说一下同步和非同步的概念

同步和非同步是操作系统级别的，主要描述操作系统在收到程序请求网络IO操作后，如果网络IO资源没有准备好，该如何响应程序

同步IO不响应程序，直到网络IO资源准备好
非同步IO返回一个标记，当网络IO资源准备好后，用事件机制通知给程序

再说一下阻塞和非阻塞的概念

阻塞和非阻塞是程序级别的，主要描述程序请求操作系统IO操作后，如果网络IO资源没有准备好，程序如何处理

阻塞IO会进行等待
非阻塞IO会继续执行，且使用线程一直轮询，直到IO资源准备好

{
        boolean flag = true;
        try {
            ServerSocket serverSocket = new ServerSocket(6666);
            // 使用超时时间来设置为非阻塞状态,超过该时间会抛出SocketTimeoutException
            serverSocket.setSoTimeout(100);

            while (true){
                Socket socket = null;
                try{
                    // 设置了超时时间后accept就不会阻塞了
                    socket  = serverSocket.accept();
                } catch (SocketTimeoutException e){
                    synchronized (obj){   // 100ms内没有接收到任何数据，可以在这里做一些别的操作
                        System.out.println("没接收到数据，先歇一歇吧");
                        try {
                            obj.wait(10);
                        } catch (InterruptedException interruptedException) {
                            interruptedException.printStackTrace();
                        }
                    }
                    continue;

                }
              // 开线程处理数据
                new Thread(socket).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

serverSocket.setSoTimeout可以使accept方法不一直阻塞，而是到了超时时间后抛出SocketTimeoutException异常，此时就可以用主线程做别的事情了，虽然实际还是使用的accept阻塞模型，但是有所改善

多路复用模型

多路复用模型(也就是NIO)不在使用操作系统级别的同步IO，目前主要实现有select、poll、epoll、kqueue

{
    ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
    Selector selector = Selector.open();
    ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
    // 设置为非阻塞
    serverSocketChannel.configureBlocking(false);
    // 绑定8080端口
    serverSocketChannel.bind(new InetSocketAddress(8080));

    // 注册监听的事件
    // ServerSocketChannel只能注册OP_ACCEPT
    // SocketChannel可注册OP_READ、OP_WRITE、OP_CONNECT
    serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);


    while(true){
        // 询问selector中准备好的事件
        selector.select();
        // 获取到上述询问拿到的事件类型
        Set<SelectionKey> selectionKeys =  selector.selectedKeys();
        Iterator<SelectionKey> iterator = selectionKeys.iterator();
        while (iterator.hasNext()){
            SelectionKey selectionKey = iterator.next();
            if(selectionKey.isAcceptable()){
                ServerSocketChannel ssc = (ServerSocketChannel) selectionKey.channel();
                // 接收到服务端的请求
                SocketChannel sc = ssc.accept();
                sc.configureBlocking(false);
                sc.register(selector,SelectionKey.OP_READ);
                // 处理过了就要移除掉，否则再次select()还会拿到该事件
                iterator.remove();
            } else if(selectionKey.isReadable()){
                SocketChannel sc = (SocketChannel) selectionKey.channel();
                byteBuffer.clear();
                int n = sc.read(byteBuffer);
                if(n > 0){
                    byteBuffer.flip();
                    Charset charset = StandardCharsets.UTF_8;
                    String message = String.valueOf(charset.decode(byteBuffer).array());
                    System.out.println(message);
                }
                sc.register(selector,SelectionKey.OP_WRITE);
                iterator.remove();
            } else if(selectionKey.isWritable()){
                SocketChannel sc = (SocketChannel) selectionKey.channel();
                ByteBuffer buffer = ByteBuffer.allocate(1024);
                buffer.put("已接收到消息".getBytes());
                buffer.flip();
                sc.write(buffer);
                iterator.remove();
            }
        }
    }

}