go 使用 epoll 实现高性能tcp服务器

在go中实现一个tcp服务器还是很简单的，至少和C/C++相比还是很简单的了。

一个简单的例子

1	listen, err := net.Listen("tcp", "0.0.0.0:8088")

只需要这样一行就可以监听了，就能等待客户端连接了。是不是还是很简单的

在C/C++中，需要依次调用socket() bind() listen() accept()函数，完成打开，绑定，监听，等待操作，才能完成等待客户端来连接。
这还没完，想要提高性能还需要自己通过 epoll等手段完成多路复用。

其实在C/C++中是通过调用系统函数来完成的，只是go把这部分东西都给包装了，只需要简单的一行就可以完成了。

其实在go中也可以通过系统函数自己来完成些事情。只是这些事情比较复杂，跨平台还不好弄，像使用了epoll就只能在linux系统上编译运行了。

废话不多说了，直接上函数吧。在go中和C/C++中区别不大，同样是通过系统调用这些函数来完成。

func Socket(domain, typ, proto int) (fd int, err error)

func Bind(fd int, sa Sockaddr) (err error) 

func Listen(s int, n int) (err error) 

func Accept(fd int) (nfd int, sa Sockaddr, err error)

在go开启tcp 服务需要用到的函数.

func EpollCreate(size int) (fd int, err error)

func EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error) 

func EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error)

在go中使用epoll需要的函数

这些函数都是在syscall 包下，所以这些函数不是所有系统下都有的，
像epoll 相关的函数，就只能在linux下才能编译过。

所以，在这里就引申出一个东西就是 条件编译
在C/C++中可以通过宏定义来实现条件编译

1
2
3

#ifdef linux
   cout<<"It is in Linux OS!"<<endl;
#endif

这段代码就只能在linux系统上才会被编译

go虽然没有这么强大的宏命令来判断，但是go中可以通过编译标签 和 文件后缀来判断。

比如在文件的第一行加上

1
2
3

// +build linux
.....
.....

这样，这个文件就只能在linux上才会被编译（注意，// +build linux下面一定要有一个空行）
详细用法看这里 go条件编译

下面开始具体的代码

//定义一个结构体存储相关的数据
type EpollM struct {
    conn map[int]*ServerConn

    socketFd int //监听socket的fd
    epollFd  int //epoll的fd
}

//开启监听
func (e *EpollM) Listen(ipAddr string, port int) error {
    //使用系统调用,打开一个socket
    fd, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_STREAM, syscall.IPPROTO_TCP)
    if err != nil {
        return err
    }

    //ip地址转换
    var addr [4]byte
    copy(addr[:], net.ParseIP(ipAddr).To4())
    net.ParseIP(ipAddr).To4()
    err = syscall.Bind(fd, &syscall.SockaddrInet4{
        Port: port,
        Addr: addr,
    })
    if err != nil {
        return err
    }

    //开启监听
    err = syscall.Listen(fd, 10)
    if err != nil {
        return err
    }
    e.socketFd = fd
    return nil
}

这样就完成了监听

下面是 epoll 处理部分


//处理epoll
func (e *EpollM) HandlerEpoll() error {
    events := make([]syscall.EpollEvent, 100)
    //在死循环中处理epoll
    for {
        //msec -1,会一直阻塞,直到有事件可以处理才会返回, n 事件个数
        n, err := syscall.EpollWait(e.epollFd, events, -1)

        if err != nil {
            return err
        }
        for i := 0; i < n; i++ {
            //先在map中是否有这个链接
            conn := e.GetConn(int(events[i].Fd))
            if conn == nil { //没有这个链接,忽略
                continue
            }
            if events[i].Events&syscall.EPOLLHUP == syscall.EPOLLHUP || events[i].Events&syscall.EPOLLERR == syscall.EPOLLERR {
                //断开||出错
                if err := e.CloseConn(int(events[i].Fd)); err != nil {
                    return err
                }
            } else if events[i].Events == syscall.EPOLLIN {
                //可读事件
                conn.Read()
            }
        }
    }
}

从连接中读写数据

//读取数据
func (s *ServerConn) Read() {
    data := make([]byte, 100)
    
    //通过系统调用,读取数据,n是读到的长度
    n, err := syscall.Read(s.fd, data)
    if n == 0 {
        return
    }
    if err != nil {
        fmt.Printf("fd %d read error:%s\n", s.fd, err.Error())
    } else {
        fmt.Printf("%d say: %s \n", s.fd, data[:n])
        s.Write([]byte(fmt.Sprintf("hello %d", s.fd)))
    }
}

//向这个链接中写数据
func (s *ServerConn) Write(data []byte) {
    _, err := syscall.Write(s.fd, data)
    if err != nil {
        fmt.Printf("fd %d write error:%s\n", s.fd, err.Error())
    }
}

最后在依次调用这些函数

package main

func main() {
    epollM := NewEpollM()
    //开启监听
    err := epollM.Listen("0.0.0.0", 8088)
    if err != nil {
        panic(err)
    }

    //创建epoll
    err = epollM.CreateEpoll()
    if err != nil {
        panic(err)
    }

    //异步处理epoll
    go func() {
        err := epollM.HandlerEpoll()
        epollM.Close()
        panic(err)
    }()

    //等待client的连接
    err = epollM.Accept()
    epollM.Close()
    panic(err)
}

到这整个服务就运行起来了，代码已经上传到github了，传送门

整个过程看下来，和C/C++实现过程还是非常相似的，都是通过系统调用完成的。也没有什么难点，就这样吧