事件驱动 IO 与高性能网络模型：epoll/Reactor/io_uring

#include <sys/epoll.h>

int epfd = epoll_create1(0);          // 创建 epoll 实例

struct epoll_event ev;
ev.events = EPOLLIN;                  // 监听可读
ev.data.fd = server_fd;
epoll_ctl(epfd, EPOLL_CTL_ADD, server_fd, &ev);  // 注册

struct epoll_event events[1024];
while (1) {
    // 阻塞等待就绪事件，O(1) 返回就绪数
    int n = epoll_wait(epfd, events, 1024, -1);
    for (int i = 0; i < n; i++) {
        int fd = events[i].data.fd;
        // 处理该 fd 的可读/可写事件
        handle_event(fd, events[i].events);
    }
}

// 边缘触发必须配合非阻塞 + 循环读尽
// 否则再次 epoll_wait 不会通知剩余数据
ev.events = EPOLLIN | EPOLLET;   // 边缘触发
fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);

// 读循环：直到 EAGAIN 才结束
while (1) {
    n = read(fd, buf, sizeof(buf));
    if (n == -1) {
        if (errno == EAGAIN) break;   // 读尽，下次等新事件
        return ERROR;
    }
    if (n == 0) break;                 // EOF
    process(buf, n);
}

// 简化版 Reactor 骨架（Linux epoll）
package main

import (
    "golang.org/x/sys/unix"
    "os"
    "syscall"
)

type Reactor struct {
    epfd int
}

func (r *Reactor) AddFD(fd int, events uint32) error {
    return unix.EpollCtl(r.epfd, unix.EPOLL_CTL_ADD, fd,
        &unix.EpollEvent{Events: events, Fd: int32(fd)})
}

func (r *Reactor) Run() error {
    events := make([]unix.EpollEvent, 128)
    for {
        n, err := unix.EpollWait(r.epfd, events, -1)
        if err == syscall.EINTR {
            continue
        }
        for i := 0; i < n; i++ {
            fd := int(events[i].Fd)
            if events[i].Events&unix.EPOLLIN != 0 {
                go handleRead(fd) // 分发到 goroutine
            }
            if events[i].Events&unix.EPOLLOUT != 0 {
                handleWrite(fd)
            }
        }
    }
}

func main() {
    r, _ := newReactor()
    go r.Run()
    select {} // 阻塞主协程
}

#include <liburing.h>

struct io_uring ring;
io_uring_queue_init(128, &ring, 0);   // 初始化环形队列

// 提交一个异步读
struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
io_uring_prep_read(sqe, fd, buf, len, 0);   // 异步读
io_uring_submit(&ring);                      // 批量提交

// 收割完成事件
struct io_uring_cqe *cqe;
io_uring_wait_cqe(&ring, &cqe);             // 等待一个完成
// cqe->res 为读取结果
io_uring_cqe_seen(&ring, cqe);              // 标记已消费

// 使用 liburing 的 Go 绑定（github.com/iceber/iouring-go）示意
package main

import (
    iouring "github.com/iceber/iouring-go"
    "os"
)

func main() {
    engine, _ := iouring.New(128)
    defer engine.Close()

    f, _ := os.OpenFile("/tmp/data.bin", os.O_RDONLY, 0)
    buf := make([]byte, 4096)

    // 提交异步读，返回一个可等待的 future
    request, err := engine.Read(f, buf)
    if err != nil {
        panic(err)
    }
    // 等待结果（等价于完成回调）
    result := <-request.Result()
    if result.Err != nil {
        panic(result.Err)
    }
    _ = result.Len // 实际读取字节数
}

# asyncio 中切忌在 async 函数里写同步阻塞调用
import asyncio

async def handle(reader, writer):
    # ❌ await 一个耗时同步函数会阻塞事件循环
    # data = heavy_sync_calc()

    # ✅ 用 run_in_executor 丢到线程池
    loop = asyncio.get_running_loop()
    data = await loop.run_in_executor(None, heavy_sync_calc)

// Go 网络服务天然高并发：每个连接一个 goroutine
func main() {
    ln, _ := net.Listen("tcp", ":8080")
    for {
        conn, _ := ln.Accept()
        go func(c net.Conn) {      // 协程调度，百万连接可行
            defer c.Close()
            buf := make([]byte, 1024)
            for {
                n, err := c.Read(buf)
                if err != nil { return }
                c.Write(buf[:n])
            }
        }(conn)
    }
}