网络 IO 全解：从硬件网卡到各语言实现

一份自底向上的图解：数据是怎么从网线，经过网卡、内核协议栈、系统调用，最后被 PHP / C / Go / Java / Python 写出来的。文中有可点击的交互演示。

一、整体架构：数据走的这条链路

应用进程并不直接碰网卡。中间隔着操作系统内核：内核替你收包、解协议、缓冲，应用再通过系统调用把数据「取」出来。下面这张图是全文的地图。

二、硬件层：网卡是怎么把比特变成字节的

最底层没有「连接」「报文」这些概念，只有电信号。理解硬件层，才能明白为什么「等待数据就绪」本质上是在等网卡 + DMA + 中断把东西搬进内存。

收包全链路（一张图看明白）

三、操作系统层：socket、缓冲区与系统调用

1) socket 是什么

对应用来说，一个网络连接就是一个 文件描述符 fd。内核为每个 socket 维护两块缓冲区：发送缓冲区（你 write/send 的数据先放这里，内核择机发出）和 接收缓冲区（内核收好的数据停在这里，等你 read/recv 取走）。这就是为什么「写」不一定立刻到网线、「读」不一定立刻有新数据——中间隔着缓冲区。

2) 关键系统调用

3) 平台上的 I/O 多路复用原语

「一个线程如何同时盯着上千个 fd」是网络编程的核心。不同 OS 给出不同答案，语言运行时底层最终都映射到它们：

四、五种 I/O 模型：区别只在「两段等待」怎么处理

Richard Stevens 在《Unix Network Programming》里把 I/O 模型分成五类。点下面的按钮，看每一类在「等待数据就绪」「拷贝到用户空间」两段里，调用线程是否被阻塞。

五、交互演示：epoll 事件循环是怎么跑的

非阻塞 + epoll 是现代高并发的基石：一个线程用 epoll_wait 同时盯住所有连接，谁就绪就处理谁，不就绪就一直等。点「播放」看模拟过程（绿=就绪、橙=处理中、蓝=完成）。

六、各语言层：同样的 epoll，不同的写法

到了语言层，本质机制都是上面那套（socket + 非阻塞 + 多路复用 / 异步）。差别在于：谁替你管事件循环、并发单位是什么、阻塞语义对开发者是否可见。点语言标签看各自思路与一段代表代码。

int sfd = socket(AF_INET, SOCK_STREAM, 0);
bind(sfd, (struct sockaddr*)&addr, sizeof addr);
listen(sfd, 128);

int epfd = epoll_create1(0);
struct epoll_event ev = {.events = EPOLLIN, .data.fd = sfd};
epoll_ctl(epfd, EPOLL_CTL_ADD, sfd, &ev);

struct epoll_event events[MAX];
while (1) {
    int n = epoll_wait(epfd, events, MAX, -1); // 阻塞，直到有 fd 就绪
    for (int i = 0; i < n; i++) {
        if (events[i].data.fd == sfd) {        // 新连接
            int cfd = accept(sfd, NULL, NULL);
            // 设为非阻塞并加入 epoll 监听 EPOLLIN
        } else {                                 // 已连接 socket 可读
            char buf[1024];
            int r = read(events[i].data.fd, buf, sizeof buf);
            write(events[i].data.fd, buf, r);     // echo 回去
        }
    }
}

// ① 传统阻塞写法（php-fpm 下，一个请求占一个进程直到完成）
$conn = stream_socket_server("tcp://0.0.0.0:9501");
while ($client = stream_socket_accept($conn)) {  // 阻塞
    $data = fread($client, 1024);            // 阻塞
    fwrite($client, $data);
}

// ② Swoole 协程：看似同步的阻塞写法，底层被 hook 成非阻塞 + 调度
Swoole\Coroutine\run(function () {
    $server = new Swoole\Coroutine\Server("0.0.0.0", 9501);
    $server->handle(function ($conn) {
        $data = $conn->recv();   // 协程在此让出，不阻塞线程
        $conn->send($data);
    });
    $server->start();
});

import asyncio

async def handle(reader, writer):
    data = await reader.read(1024)   # 让出控制权，不阻塞线程
    writer.write(data)
    await writer.drain()
    writer.close()

async def main():
    server = await asyncio.start_server(handle, "0.0.0.0", 9501)
    async with server:
        await server.serve_forever()

asyncio.run(main())

// Java NIO：Selector 多路复用（Reactor 单线程版骨架）
Selector selector = Selector.open();
serverChannel.configureBlocking(false);
serverChannel.register(selector, SelectionKey.OP_ACCEPT);

while (true) {
    selector.select();                    // 阻塞，等就绪事件
    Set<SelectionKey> keys = selector.selectedKeys();
    for (SelectionKey key : keys) {
        if (key.isAcceptable()) {        // 新连接
            SocketChannel c = serverChannel.accept();
            c.configureBlocking(false);
            c.register(selector, SelectionKey.OP_READ);
        } else if (key.isReadable()) {     // 可读
            ByteBuffer buf = ByteBuffer.allocate(1024);
            ((SocketChannel) key.channel()).read(buf);
            // echo 写回，注册 OP_WRITE…
        }
    }
}

func handle(conn net.Conn) {
    defer conn.Close()
    buf := make([]byte, 1024)
    for {
        n, err := conn.Read(buf)   // 只阻塞当前 goroutine，不阻塞线程
        if err != nil { return }
        conn.Write(buf[:n])        // echo
    }
}
func main() {
    ln, _ := net.Listen("tcp", ":9501")
    for {
        conn, _ := ln.Accept()     // 同样只阻塞 goroutine
        go handle(conn)         // 每连接一个 goroutine
    }
}

七、全景对比：五种语言怎么选

点表格里的语言名可高亮对应行。核心结论：底层机制殊途同归（都是 epoll/kqueue/IOCP + 非阻塞），差异在并发抽象与开发者心智模型。

八、交互演示：一次 read 的完整生命周期

把前面所有层串起来。点「播放」，看一个数据包从网线到你的 Python/Go 代码经历了哪些层、在哪里「等待」。