Java 网络IO模型

咿咿呀嘿
21 阅读7分钟

一篇文章带你彻底搞懂BIO，NIO，AIO。

BIO(Blocking IO)

同步阻塞模型，一个客户端连接对应一个处理线程。 在这里插入图片描述

代码示例

服务端代码

package nio.io.bio;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class BIOServer {
  public static void main(String[] args) throws IOException {
    ServerSocket serverSocket = new ServerSocket(8080);
    while (true) {
      System.out.println("server服务启动，等待连接。。");
      //等待客户端链接 阻塞方法
      Socket clientSocket = serverSocket.accept();
      System.out.println("客户端链接成功。。");
      handler(clientSocket);

            /*new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        handler(clientSocket);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();*/
    }
  }

  private static void handler(Socket clientSocket) throws IOException {
    byte[] bytes = new byte[1024];
    System.out.println("准备read。。");
    //接收客户端的数据，阻塞方法，没有数据可读时就阻塞
    int read = clientSocket.getInputStream().read(bytes);
    System.out.println("read完毕。。");
    if (read != -1) {
      System.out.println("接收到客户端的数据：" + new String(bytes, 0, read));
    }
    clientSocket.getOutputStream().write("HelloClient".getBytes());
    clientSocket.getOutputStream().flush();
  }
}

客户端代码

package nio.io.bio;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class BIOClient {
  public static void main(String[] args) throws IOException {
    Socket socket = new Socket("localhost", 8080);
    //向服务端发送数据
    socket.getOutputStream().write("HelloServer".getBytes());
    socket.getOutputStream().flush();
    System.out.println("向服务端发送数据结束");
    byte[] bytes = new byte[1024];
    //接收服务端回传的数据
    socket.getInputStream().read(bytes);
    System.out.println("接收到服务端的数据：" + new String(bytes));
    socket.close();
  }
}

缺点

  1. IO代码里read操作是阻塞操作，如果连接不做数据读写操作会导致线程阻塞，浪费资源
  2. 如果线程很多，会导致线程太多，压力太大，比如C10K问题

NIO(Non Blocking IO)

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

基础版 NIO

public class NioServer {

  // 保存客户端连接
  static List<SocketChannel> channelList = new ArrayList<>();

  public static void main(String[] args) throws IOException, InterruptedException {

    // 创建NIO ServerSocketChannel,与BIO的serverSocket类似
    ServerSocketChannel serverSocket = ServerSocketChannel.open();
    serverSocket.socket().bind(new InetSocketAddress(9000));
    // 设置ServerSocketChannel为非阻塞
    serverSocket.configureBlocking(false);
    System.out.println("服务启动成功");

    while (true) {
      // 非阻塞模式accept方法不会阻塞，否则会阻塞
      // NIO的非阻塞是由操作系统内部实现的，底层调用了linux内核的accept函数
      SocketChannel socketChannel = serverSocket.accept();
      if (socketChannel != null) { // 如果有客户端进行连接
        System.out.println("连接成功");
        // 设置SocketChannel为非阻塞
        socketChannel.configureBlocking(false);
        // 保存客户端连接在List中
        channelList.add(socketChannel);
      }
      // 遍历连接进行数据读取
      Iterator<SocketChannel> iterator = channelList.iterator();
      while (iterator.hasNext()) {
        SocketChannel sc = iterator.next();
        ByteBuffer byteBuffer = ByteBuffer.allocate(128);
        // 非阻塞模式read方法不会阻塞，否则会阻塞
        int len = sc.read(byteBuffer);
        // 如果有数据，把数据打印出来
        if (len > 0) {
          System.out.println("接收到消息：" + new String(byteBuffer.array()));
        } else if (len == -1) { // 如果客户端断开，把socket从集合中去掉
          iterator.remove();
          System.out.println("客户端断开连接");
        }
      }
    }
  }
}

基础版Nio实现非常简单，就是当有客户端连接时，将客户端的channel保存到channelList中。遍历channeList，看看哪个客户端通过channel发送消息，将消息打印。

可这种形式，如果链接过多，会有大量的无效遍历浪费性能。举例子假如有10000个连接，其中只有1000个连接有写数据，但是由于其他9000个连接并没有断开，我们还是要每次轮询遍历一万次，其中有十分之九的遍历都是无效的。

引入多路复用器

来一张图直观感受一下吧 NioSelector

示例代码

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

public class NioSelectorServer {

    public static void main(String[] args) throws IOException, InterruptedException {

        // 创建NIO ServerSocketChannel
        ServerSocketChannel serverSocket = ServerSocketChannel.open();
        serverSocket.socket().bind(new InetSocketAddress(9000));
        // 设置ServerSocketChannel为非阻塞
        serverSocket.configureBlocking(false);
        // 打开Selector处理Channel，即创建epoll
        Selector selector = Selector.open();
        // 把ServerSocketChannel注册到selector上，并且selector对客户端accept连接操作感兴趣
        serverSocket.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("服务启动成功");

        while (true) {
            // 阻塞等待需要处理的事件发生
            selector.select();

            // 获取selector中注册的全部事件的 SelectionKey 实例
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();

            // 遍历SelectionKey对事件进行处理
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                // 如果是OP_ACCEPT事件，则进行连接获取和事件注册
                if (key.isAcceptable()) {
                    ServerSocketChannel server = (ServerSocketChannel) key.channel();
                    SocketChannel socketChannel = server.accept();
                    socketChannel.configureBlocking(false);
                    // 这里只注册了读事件，如果需要给客户端发送数据可以注册写事件
                    socketChannel.register(selector, SelectionKey.OP_READ);
                    System.out.println("客户端连接成功");
                } else if (key.isReadable()) {  // 如果是OP_READ事件，则进行读取和打印
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    ByteBuffer byteBuffer = ByteBuffer.allocate(128);
                    int len = socketChannel.read(byteBuffer);
                    // 如果有数据，把数据打印出来
                    if (len > 0) {
                        System.out.println("接收到消息：" + new String(byteBuffer.array()));
                    } else if (len == -1) { // 如果客户端断开连接，关闭Socket
                        System.out.println("客户端断开连接");
                        socketChannel.close();
                    }
                }
                //从事件集合里删除本次处理的key，防止下次select重复处理
                iterator.remove();
            }
        }
    }
}

详细介绍

这也是NIO现在使用常用的形态了，让我们来详细了解一下这种形式吧。

NIO 有三大核心组件： Channel(通道)， Buffer(缓冲区)，Selector(多路复用器) 1、channel 类似于流，每个 channel 对应一个 buffer缓冲区，buffer 底层就是个数组 2、channel 会注册到 selector 上，由 selector 根据 channel 读写事件的发生将其交由某个空闲的线程处理 3、NIO 的 Buffer 和 channel 都是既可以读也可以写

关于多路复用器如何实现？channel如何注册到selector，selector如何管理channel，如何实现监听channel读写事件而不用遍历selector上全部的channel等这些需要了解Linux内核中epoll。

//创建多路复用器 ，其实底层就是创建Linux的epoll。
Selector.open()
//将channel注册到多路复用器上 ，也是将channel连接交给了Linux的epoll进行管理
socketChannel.register(selector, SelectionKey.OP_READ) 
//阻塞该线程等待需要处理的事件发生，等来epoll上注册的事件响应从而唤起该线程这一步不再阻塞
selector.select()

NIO整个调用流程就是Java调用了操作系统内核函数来创建Socket，在创建一个Selector对象，对应操作系统的Epoll描述符，将获取到的Socket连接的文件描述符的事件绑定到Selector对应的Epoll文件描述符上，进行事件的异步通知，这样实现了使用一条线程，并且不需要太多的无效遍历，将事件处理交给了操作系统内核（操作系统中断程序实现），大大提高效率。

AIO

异步非阻塞，由操作系统完成后回调通知服务端程序启动线程去处理，一般适用于连接数较多且连接时间较长的应用。

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;

public class AIOServer {
  public static void main(String[] args) throws Exception {
    final AsynchronousServerSocketChannel serverChannel =
        AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(9000));

    serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {
      @Override
      public void completed(AsynchronousSocketChannel socketChannel, Object attachment) {
        try {
          System.out.println("2--"+Thread.currentThread().getName());
          // 再此接收客户端连接，如果不写这行代码后面的客户端连接连不上服务端
          serverChannel.accept(attachment, this);
          System.out.println(socketChannel.getRemoteAddress());
          ByteBuffer buffer = ByteBuffer.allocate(1024);
          socketChannel.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
            @Override
            public void completed(Integer result, ByteBuffer buffer) {
              System.out.println("3--"+Thread.currentThread().getName());
              buffer.flip();
              System.out.println(new String(buffer.array(), 0, result));
              socketChannel.write(ByteBuffer.wrap("HelloClient".getBytes()));
            }

            @Override
            public void failed(Throwable exc, ByteBuffer buffer) {
              exc.printStackTrace();
            }
          });
        } catch (IOException e) {
          e.printStackTrace();
        }
      }

      @Override
      public void failed(Throwable exc, Object attachment) {
        exc.printStackTrace();
      }
    });

    System.out.println("1--"+Thread.currentThread().getName());
    Thread.sleep(Integer.MAX_VALUE);
  }
}

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;

public class AIOClient {
    public static void main(String... args) throws Exception {
        AsynchronousSocketChannel socketChannel = AsynchronousSocketChannel.open();
        socketChannel.connect(new InetSocketAddress("127.0.0.1", 9000)).get();
        socketChannel.write(ByteBuffer.wrap("HelloServer".getBytes()));
        ByteBuffer buffer = ByteBuffer.allocate(512);
        Integer len = socketChannel.read(buffer).get();
        if (len != -1) {
            System.out.println("客户端收到信息：" + new String(buffer.array(), 0, len));
        }
    }
}

总结

同步阻塞 客户端连接，服务端一个专有线程处理，一个线程只能处理一个客户端连接。 BIO是同步阻塞 客户端请求连接，服务端启用一个线程等待客户端传输数据，直至客户端关闭连接。

同步非阻塞 客户端连接，服务端就一个专有线程处理，服务端线程可以处理多个客户端连接。 NIO是同步非阻塞 客户端请求连接，服务端将客户端Socket注册到selector上（线程不会阻塞，等待客户端传输数据）。当客户端向服务端传输数据完成后，服务端主动获取客户端传输的数据。

异步非阻塞 客户端连接，服务端就异步启线程处理任务。 AIO是异步非阻塞 每当客户端连接，服务端就会异步启动线程进行处理连接。

avatar
文章
阅读
粉丝