bio/nio记录

bio server程序:

    public static void main(String[] args) throws Exception
    {
        ServerSocket server = new ServerSocket(8888);
        while (true)
        {
            // 阻塞
            Socket socket = server.accept();
            new Thread(() -> {
                try
                {
                    InputStream in = socket.getInputStream();
                    BufferedReader reader = new BufferedReader(new InputStreamReader(in));
                    while (true)
                    {
                        // 阻塞
                        System.out.println(reader.readLine());
                    }
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }
            }).start();
        }
    }

bio的问题是它的read, write方法都是阻塞的, 例如上述程序中的reader.readLine(); 如果客户端连上了但是不发送数据, 服务端就一直阻塞在这里, 就没有办法和新的客户端建立连接
所以不得不为每一个socket都创建一个进程/线程来进行处理, 不让io阻塞住主线程

由此就可以看出bio的开销:

  1. 创建线程需要开销, client越多, 需要的线程也就越多
  2. 多线程上下文切换需要开销

而造成这些开销的根本原因就是io是阻塞的, 如果io是非阻塞的, 也就不需要开辟那么多线程了

假设现在有一个read方法是非阻塞的:

// 伪代码
while(true)
{
    // 非阻塞
    Socket socket = server.accept();
    if (socket != null)
    {
        list.add(socket);
    }
    foreach(list)
    {
        // 非阻塞
        socket.getInputStream().read(); 
    }
}

上述代码就完成了由一个线程去处理多个socket, 但是仍然存在很大的开销.
例如现在这个list里存了1w个socket, 那么每次foreach都要调1w次read方法.

io都是要操作硬件的, 操作硬件的接口都是由操作系统暴露的(系统调用), 并且这些接口只能在操作系统的掌控/环境下执行(内核态). 而正常程序的运行是在用户态运行的, 用户态到内核态的切换是要开销的(例如保存现场切换堆栈....)

所以有1w个socket要读就进行1w次系统调用是不太合适的, 而且这1w个socket可能也就只有1个socket是有数据可以读的, 而剩下的9999次系统调用都是浪费掉的

所以有了io多路复用器, 这仍是一个用一个线程处理多个socket的技术

while(true)
{
    List<Socket> activeList = select(list)
    foreach(activeList)
    // ...
}

select就是一个io多路复用器, 把1w个socket都仍给它, 由它来返回哪几个是有数据可以读的socket, 再由程序去处理
select相比上一种的好处就是 我一次把1w个socket都丢给了内核态, 在内核态中进行遍历, 然后只返回有数据交互的socket, 大大减少了系统调用的次数

不过内核去遍历所有的socket还是有开销, 所以有了epoll
epoll是一种事件驱动的机制, 在内核中开辟两块空间a和b, 每来一个socket就往a里放, 并且把这个socket绑定一个事件例如accept/read..., 将来该socket对应的事件发生后, 该socket回移到b里, 而应用程序就是每次从b里得到activeList
而从a移到b是靠的网卡的中断

image.png

nio就是对epoll的封装, channel就可以看做是fd, 可读可写
selector就可以看做是监听a的监听器
selector.selectedKeys()就是从b获取有事件发生了的fd, 相当于epoll_wait channel.register()就相当于把fd(channel)放到a中, 类比epoll_ctl

public void start()
{
        try
        {
            channel = ServerSocketChannel.open();
            // 开启非阻塞模式
            channel.configureBlocking(false);
            // 得到与channel相关的ServerSocket并绑定端口
            channel.socket().bind(new InetSocketAddress(port));
            selector = Selector.open();
            // 让selector监控channel上的accept事件
            channel.register(selector, SelectionKey.OP_ACCEPT);
            while (true)
            {
                // 返回 监控到的所有通道上触发的事件 的个数
                // 如果一个也没触发, 就阻塞
                selector.select();
                // 获取被触发事件的相关信息
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                for (SelectionKey key : selectionKeys)
                {
                    handle(key);
                }
                // 要清空, 不然下一次循环还有这一次的数据
                selectionKeys.clear();
            }
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        finally
        {
            close();
        }
    }

    private void handle(SelectionKey key) throws IOException
    {
        // 如果是accept事件(和客户端建立了连接)被触发
        if (key.isAcceptable())
        {
            // 返回当前key所属的通道, 返回的是 this.channel
            ServerSocketChannel server = (ServerSocketChannel) key.channel();
            // 返回一个用户和客户端通信的SocketChannel
            SocketChannel client = server.accept();
            client.configureBlocking(false);
            // 让selector监控该client通道上的read事件, 以便该客户端向server发送信息时,可以处理
            client.register(selector, SelectionKey.OP_READ);
            System.out.println("客户端: [" + getClientText(client.socket()) + "]进入聊天室...");
        }
        // 如果有客户端发来消息
        else if (key.isReadable())
        {
            SocketChannel client = (SocketChannel) key.channel();
            // 接收客户端发来的消息
            String fwdMsg = receive(client);
            // 客户端异常
            if (fwdMsg.isEmpty())
            {
                // 取消 key所属的通道的响应事件的监听
                key.cancel();
                // selector的状态有所变化, select函数重新执行
                selector.wakeup();
            }
            else
            {
                // 转发消息, 不要转发给自己
                forwardMessage(client, fwdMsg);
                if(readyToExit(fwdMsg))
                {
                    key.cancel();
                    selector.wakeup();
                    System.out.println(getClientText(client.socket()) + "已下线...");
                }
            }
        }
    }

select, epoll都是同步的
他们都只是多路复用器, 程序仅仅是通过多路复用器知道了哪些socket是可以去操作的, 但具体的io操作还是程序自己去发起, 所以是同步的

推荐阅读更多精彩内容