聊聊go语言基于epoll的网络并发实现

package main
 
import (
    "fmt"
    "net"
    "syscall"
    "time"
)
 
// 定义网络IO事件类型
type Event int
 
const (
    READ Event = 1 << iota
    WRITE
)
 
// 定义网络连接结构体
type Conn struct {
    fd      int
    events  Event
    lastUse time.Time
}
 
// 创建新的网络连接
func newConn(fd int, events Event) *Conn {
    return &Conn{
        fd:      fd,
        events:  events,
        lastUse: time.Now(),
    }
}
 
// 检查连接是否可读
func (c *Conn) isReadable() bool {
    return c.events&READ == READ
}
 
// 检查连接是否可写
func (c *Conn) isWritable() bool {
    return c.events&WRITE == WRITE
}
 
// 定义事件循环结构体
type EventLoop struct {
    // 这里可以包含其他必要的字段，例如epoll文件描述符、连接池等
}
 
// 初始化事件循环
func (el *EventLoop) Init() error {
    // 初始化epoll，并设置EPOLLONESHOT，防止轮询
    epfd, err := syscall.EpollCreate1(syscall.EPOLL_CLOEXEC)
    if err != nil {
        return err
    }
    // 初始化其他字段，例如连接池等
    el.epfd = epfd
    return nil
}
 
// 添加连接到事件循环
func (el *EventLoop) AddConn(conn *Conn, events Event) error {
    // 设置非阻塞模式
    if err := setNonblock(conn.fd); err != nil {
        return err
    }
    // 添加到epoll
    event := syscall.EpollEvent{
        Fd:     int32(conn.fd),
        Events: uint32(events),
    }
    if err := syscall.EpollCtl(el.epfd, syscall.EPOLL_CTL_ADD, conn.fd, &event); err != nil {
        return err
    }
    // 添加到连接池等
    return nil
}
 
// 运行事件循环
func (el *EventLoop) Run() error {
    events := make([]syscall.EpollEvent, 10)
    for {
        nevents, err := syscall.EpollWait(el.epfd, events[:], -1)
        if err != nil {
            return err
        }
        for i := 0; i < nevents; i++ {
            // 处理事件
            conn := getConn(events[i].Fd) // 假设有方法可以根据fd获取连接
            if events[i].Events&syscall.EPOLLIN == syscall.EPOLLIN {
                // 读取数据
            }
            if events[i].Events&syscall.EPOLLOUT == syscall.EPOLLOUT {
                // 发送数据
            }
            // 更新连接的最后使用时间等
        }
    }
}
 
// 设置socket为非阻塞模式
func setNonblock(fd int) error {
    return syscall.SetNonblock(fd, true)
}
 
func main() {
    // 初始化事件循环
    eventLoop := &EventLoop{}
    if err := eventLoop.Init(); err != nil {
        fmt.Println("初始化事件循环失败:", err)
        retu