從作業系統層面理解Linux下的網路IO模型

I/O（ INPUT OUTPUT），包括檔案I/O、網路I/O。 計算機世界裡的速度鄙視：

• 記憶體讀資料：納秒級別。

• 千兆網路卡讀資料：微妙級別。1微秒=1000納秒，網路卡比記憶體慢了千倍。

• 磁碟讀資料：毫秒級別。1毫秒=10萬納秒 ，硬碟比記憶體慢了10萬倍。

• CPU一個時鐘週期1納秒上下，記憶體算是比較接近CPU的，其他都等不起。

CPU 處理資料的速度遠大於I/O準備資料的速度 。

任何程式語言都會遇到這種CPU處理速度和I/O速度不匹配的問題！

在網路程式設計中如何進行網路I/O優化：怎麼高效地利用CPU進行網路資料處理？？？

相關概念

從作業系統層面怎麼理解網路I/O呢？ 計算機的世界有一套自己定義的概念。如果不明白這些概念，就無法真正明白技術的設計思路和本質。所以在我看來，這些概念是瞭解技術和計算機世界的基礎。

1.1 同步與非同步，阻塞與非阻塞

理解網路I/O避不開的話題：同步與非同步，阻塞與非阻塞。拿山治燒水舉例來說，(山治的行為好比使用者程式，燒水好比核心提供的系統呼叫)，這兩組概念翻譯成大白話可以這麼理解。

• 同步/非同步關注的是水燒開之後需不需要我來處理。
• 阻塞/非阻塞關注的是在水燒開的這段時間是不是幹了其他事。

1.1.1 同步阻塞

點火後，傻等，不等到水開堅決不幹任何事（阻塞），水開了關火（同步）。

1.1.2 同步非阻塞

點火後，去看電視（非阻塞），時不時看水開了沒有，水開後關火（同步）。

1.1.3 非同步阻塞

按下開關後，傻等水開（阻塞），水開後自動斷電（非同步）。

網路程式設計中不存在的模型。

1.1.4 非同步非阻塞

按下開關後，該幹嘛幹嘛 （非阻塞），水開後自動斷電（非同步）。

1.2 核心空間 、使用者空間

• 核心負責網路和檔案資料的讀寫。
• 使用者程式通過系統呼叫獲得網路和檔案的資料。

1.2.1 核心態 使用者態

• 程式為讀寫資料不得不發生系統呼叫。
• 通過系統呼叫介面，執行緒從使用者態切換到核心態，核心讀寫資料後，再切換回來。
• 程式或執行緒的不同空間狀態。

1.2.2 執行緒的切換

使用者態和核心態的切換耗時，費資源（記憶體、CPU）優化建議：

• 更少的切換。
• 共享空間。

1.3 套接字 – socket

• 有了套接字，才可以進行網路程式設計。
• 應用程式通過系統呼叫socket(),建立連線，接收和傳送資料（I / O）。
• SOCKET 支援了非阻塞，應用程式才能非阻塞呼叫，支援了非同步，應用程式才能非同步呼叫

1.4 檔案描述符 –FD 控制程式碼

**網路程式設計都需要知道FD？？？FD是個什麼鬼？？？**Linux：萬物都是檔案，FD就是檔案的引用。像不像JAVA中萬物都是物件?程式中操作的是物件的引用。JAVA中建立物件的個數有記憶體的限制，同樣FD的個數也是有限制的。

Linux在處理檔案和網路連線時，都需要開啟和關閉FD。每個程式都會有預設的FD：

• 0 標準輸入 stdin
• 1 標準輸出 stdout
• 2 錯誤輸出 stderr

1.5 服務端處理網路請求的過程

• 連線建立後。
• 等待資料準備好（CPU 閒置）。
• 將資料從核心拷貝到程式中（CPU閒置）。

**怎麼優化呢？**對於一次I/O訪問（以read舉例），資料會先被拷貝到作業系統核心的緩衝區，然後才會從作業系統核心的緩衝區拷貝到應用程式的地址空間。所以說，當一個read操作發生時，它會經歷兩個階段：

• 等待資料準備 (Waiting for the data to be ready)。
• 將資料從核心拷貝到程式中 (Copying the data from the kernel to the process)。

正是因為這兩個階段，Linux系統升級迭代中出現了下面三種網路模式的解決方案。

I/O模型

2.1 阻塞 I/O - Blocking I/O

簡介：最原始的網路I/O模型。程式會一直阻塞，直到資料拷貝完成。缺點：高併發時，服務端與客戶端對等連線，執行緒多帶來的問題：

• CPU資源浪費，上下文切換。
• 記憶體成本幾何上升，JVM一個執行緒的成本約1MB。

public static void main(String[] args) throws IOException {
        ServerSocket ss = new ServerSocket();
        ss.bind(new InetSocketAddress(Constant.HOST, Constant.PORT));
        int idx =0;
        while (true) {
            final Socket socket = ss.accept();//阻塞方法
            new Thread(() -> {
                handle(socket);
            },"執行緒["+idx+"]" ).start();
        }
    }

    static void handle(Socket socket) {
        byte[] bytes = new byte[1024];
        try {
            String serverMsg = "  server sss[ 執行緒："+ Thread.currentThread().getName() +"]";
            socket.getOutputStream().write(serverMsg.getBytes());//阻塞方法
            socket.getOutputStream().flush();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
複製程式碼

2.2 非阻塞 I/O - Non Blocking IO

簡介：程式反覆系統呼叫，並馬上返回結果。缺點：當程式有1000fds,代表使用者程式輪詢發生系統呼叫1000次kernel，來回的使用者態和核心態的切換，成本幾何上升。

public static void main(String[] args) throws IOException {
        ServerSocketChannel ss = ServerSocketChannel.open();
        ss.bind(new InetSocketAddress(Constant.HOST, Constant.PORT));
        System.out.println(" NIO server started ... ");
        ss.configureBlocking(false);
        int idx =0;
        while (true) {
            final SocketChannel socket = ss.accept();//阻塞方法
            new Thread(() -> {
                handle(socket);
            },"執行緒["+idx+"]" ).start();
        }
    }
    static void handle(SocketChannel socket) {
        try {
            socket.configureBlocking(false);
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            socket.read(byteBuffer);
            byteBuffer.flip();
            System.out.println("請求：" + new String(byteBuffer.array()));
            String resp = "伺服器響應";
            byteBuffer.get(resp.getBytes());
            socket.write(byteBuffer);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
複製程式碼

2.3 I/O 多路複用 - IO multiplexing

簡介：單個執行緒就可以同時處理多個網路連線。核心負責輪詢所有socket，當某個socket有資料到達了，就通知使用者程式。多路複用在Linux核心程式碼迭代過程中依次支援了三種呼叫，即SELECT、POLL、EPOLL三種多路複用的網路I/O模型。下文將畫圖結合Java程式碼解釋。

2.3.1 I/O 多路複用- select

簡介：有連線請求抵達了再檢查處理。缺點：

• 控制程式碼上限- 預設開啟的FD有限制,1024個。
• 重複初始化-每次呼叫 select()，需要把 fd 集合從使用者態拷貝到核心態，核心進行遍歷。
• 逐個排查所有FD狀態效率不高。

服務端的select 就像一塊佈滿插口的插排，client端的連線連上其中一個插口，建立了一個通道，然後再在通道依次註冊讀寫事件。一個就緒、讀或寫事件處理時一定記得刪除，要不下次還能處理。

public static void main(String[] args) throws IOException {
        ServerSocketChannel ssc = ServerSocketChannel.open();//管道型ServerSocket
        ssc.socket().bind(new InetSocketAddress(Constant.HOST, Constant.PORT));
        ssc.configureBlocking(false);//設定非阻塞
        System.out.println(" NIO single server started, listening on :" + ssc.getLocalAddress());
        Selector selector = Selector.open();
        ssc.register(selector, SelectionKey.OP_ACCEPT);//在建立好的管道上，註冊關心的事件 就緒
        while(true) {
            selector.select();
            Set<SelectionKey> keys = selector.selectedKeys();
            Iterator<SelectionKey> it = keys.iterator();
            while(it.hasNext()) {
                SelectionKey key = it.next();
                it.remove();//處理的事件，必須刪除
                handle(key);
            }
        }
    }
    private static void handle(SelectionKey key) throws IOException {
        if(key.isAcceptable()) {
                ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
                SocketChannel sc = ssc.accept();
                sc.configureBlocking(false);//設定非阻塞
                sc.register(key.selector(), SelectionKey.OP_READ );//在建立好的管道上，註冊關心的事件 可讀
        } else if (key.isReadable()) { //flip
            SocketChannel sc = null;
                sc = (SocketChannel)key.channel();
                ByteBuffer buffer = ByteBuffer.allocate(512);
                buffer.clear();
                int len = sc.read(buffer);
                if(len != -1) {
                    System.out.println("[" +Thread.currentThread().getName()+"] recv :"+ new String(buffer.array(), 0, len));
                }
                ByteBuffer bufferToWrite = ByteBuffer.wrap("HelloClient".getBytes());
                sc.write(bufferToWrite);
        }
    }
複製程式碼

2.3.2 I/O 多路複用 – poll

簡介：設計新的資料結構(連結串列)提供使用效率。poll和select相比在本質上變化不大，只是poll沒有了select方式的最大檔案描述符數量的限制。缺點：逐個排查所有FD狀態效率不高。

2.3.3 I/O 多路複用- epoll

簡介：沒有fd個數限制，使用者態拷貝到核心態只需要一次，使用事件通知機制來觸發。通過epoll_ctl註冊fd，一旦fd就緒就會通過callback回撥機制來啟用對應fd，進行相關的I/O操作。缺點：

• 跨平臺，Linux 支援最好。
• 底層實現複雜。
• 同步。

 public static void main(String[] args) throws Exception {
        final AsynchronousServerSocketChannel serverChannel = AsynchronousServerSocketChannel.open()
                .bind(new InetSocketAddress(Constant.HOST, Constant.PORT));
        serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {
            @Override
            public void completed(final AsynchronousSocketChannel client, Object attachment) {
                serverChannel.accept(null, this);
                ByteBuffer buffer = ByteBuffer.allocate(1024);
                client.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
                    @Override
                    public void completed(Integer result, ByteBuffer attachment) {
                        attachment.flip();
                        client.write(ByteBuffer.wrap("HelloClient".getBytes()));//業務邏輯
                    }
                    @Override
                    public void failed(Throwable exc, ByteBuffer attachment) {
                        System.out.println(exc.getMessage());//失敗處理
                    }
                });
            }

            @Override
            public void failed(Throwable exc, Object attachment) {
                exc.printStackTrace();//失敗處理
            }
        });
        while (true) {
            //不while true main方法一瞬間結束
        }
    }
複製程式碼

當然上面的缺點相比較它優點都可以忽略。JDK提供了非同步方式實現，但在實際的Linux環境中底層還是epoll，只不過多了一層迴圈，不算真正的非同步非阻塞。而且就像上圖中程式碼呼叫，處理網路連線的程式碼和業務程式碼解耦得不夠好。Netty提供了簡潔、解耦、結構清晰的API。

 public static void main(String[] args) {
        new NettyServer().serverStart();
        System.out.println("Netty server started !");
    }

    public void serverStart() {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        ServerBootstrap b = new ServerBootstrap();
        b.group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class)
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        ch.pipeline().addLast(new Handler());
                    }
                });
        try {
            ChannelFuture f = b.localAddress(Constant.HOST, Constant.PORT).bind().sync();
            f.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
}

class Handler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf buf = (ByteBuf) msg;
        ctx.writeAndFlush(msg);
        ctx.close();
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}
複製程式碼

bossGroup 處理網路請求的大管家（們），網路連線就緒時，交給workGroup幹活的工人（們）。

總結

回顧

• 同步/非同步，連線建立後，使用者程式讀寫時，如果最終還是需要使用者程式來呼叫系統read()來讀資料，那就是同步的，反之是非同步。Windows實現了真正的非同步，核心程式碼甚為複雜，但對使用者程式來說是透明的。

• 阻塞/非阻塞，連線建立後，使用者程式在等待可讀可寫時，是不是可以幹別的事兒。如果可以就是非阻塞，反之阻塞。大多數作業系統都支援的。

Redis,Nginx,Netty,Node.js 為什麼這麼香？

這些技術都是伴隨Linux核心迭代中提供了高效處理網路請求的系統呼叫而出現的。瞭解計算機底層的知識才能更深刻地理解I/O，知其然，更要知其所以然。與君共勉！