我有一个供客户端连接的 TCP 服务端程序。它十分简单。但问题是，所有的客户端都使用手机移动网络并且网络总是不稳定。经常丢失连接却没有通过FIN或者RST包通知服务端。服务端保持着这个虚连接并且认为这个客户端仍然在线，而事实上却不是。
我的首个解决方案是等待一小会；如果某个客户端在给定的时间端没有发送任何数据，则在服务端关闭这个连接（值得一提，SetDeadline [2] 方法十分好用，当超时时它在conn.Read上返回i/o超时错误）。但是以下情况需要考虑：我不能把超时设置得过小，因为客户端生成数据的速度可能很慢，而且也不能把超时设置得过大，因为这会使我误判客户端的在线状态，而事实上我需要一定的精度。
我的想法是 ping 客户端。但是我不想给客户端发送它不需要的垃圾数据。而且，客户端的代码也不由我说了算，所以我也不确定如果我发送一些奇怪的数据给客户端，客户端会如何表现。
TCP-keepalive — 一个轻量级的 ping
TCP keepalive发送没有（或者几乎没有）包体负载的 TCP 报文给对端，并且对端会回复 keepalive ACK确认包。它不是 TCP 标准的一部分（尽管在RFC1122 [3] 中有相关的描述），并且，它总是默认被禁用。尽管如此，大部分现代的 TCP 协议栈都支持这个特性。
在它的大部分实现中，简单来说，有三个主要参数：
- Idle time （空闲时间） – 接收一个包后，等待多长时间发出一个 ping 包。
- Retry interval （重试间隔时间） – 如果发送了一个 ping，但是没有收到对端回复的ACK，在重试间隔时间之后重新发送 ping。
- Ping amount （重试次数） – 重试次数（没有收到对端ACK）达到多少次后，我们认为这个连接不存活了。
举个例子， 空闲时间 是 30 秒， 重试间隔时间 是 5 秒， 重试次数 为 3。以下是它的工作方式：
服务端收到客户端的一包应用层数据。然后客户端不再发送任何数据。服务端等待 30 秒。然后发送一个 ping 给客户端。如果服务端收到了ACK，则服务端等待另一个 30 秒，再次发送 ping；如果在这 30 秒内服务端收到了数据，则 30 秒的定时器被重置。
如果服务端没有收到ACK，等待 5 秒后再次发送 ping。如果再过 5 秒还是没有收到回复？发送最后一个 ping 并等待最后一个 5 秒（是的，在最后一个 ping 也需要等待 重试间隔时间 ）。然后我们认为这个连接超时了并且在服务端断开它。
默认值
据说 Window 系统在发送 keepalive ping 之前默认等待 2 小时。Linux 下获取默认值十分简单，就像此处 3.1.1 节 [4] 描述的这样。
# Idle time cat /proc/sys/ net / ipv4 /tcp_keepalive_time # Retry interval cat /proc/sys/net/ipv4/tcp_keepalive_intvl # Ping amount cat /proc/sys/net/ipv4/tcp_keepalive_probes
在 Go 语言中如何设置？
由于我最近使用 Go 语言比较多，我需要在 Go 语言中运用 TCP keepalive。
讨论开始之前需要说明，以下内容适用于 Linux。我不是百分百确定它是否适用于 OSX，但我几乎可以肯定它不适用于 Windows。
连接的特殊类型
首先，我注意到我在服务端程序中只使用了net.Conn [5] 类型。但是它并不管用，它缺少我们需要的特定方法。我们需要TCPConn [6] 类型。
这意味着，我们需要使用ListenTCP [7] 和 Accept TCP [8] 而不是Listen [9] 和Accept [10] （它们的调用方式有区别，ListenTCP使用结构体而不是字符串来表示地址。我们调用方式大概会像这样：ListenTCP(“tcp”, &net.TCPAddr{Port: myClientPort})。如果你不特别指定的话，IP 的默认值为0.0.0.0）。之后它会返回我们需要的类型TCPConn。
Go 语言提供的方法
如果你翻看文档可能会注意到这两个相关的方法：SetKeepAlive [11] 和SetKeepAlivePeriod [12] 。func (c *TCPConn) SetKeepAlive(keepalive bool) error的调用方式十分简单：传入true从而打开 TCP keepalive 机制。
但是接下来的func (c *TCPConn) SetKeepAlivePeriod(d time.Duration) error就有些令人困惑了。我们用它究竟设置的是什么？答案可以在这篇文章 [13] （好文章，推荐阅读）中找到：它同时设置了 空闲时间 和 重试间隔时间 。而 重试间隔次数 则使用系统的默认值。所以如果我设置5 * time.Second。那么它可能是等待 5 秒钟，发送 ping 并等待另一个 5 秒。并且 8 次重试（取决于系统设置）。而我需要更大的灵活性，设置得更精准。
进入系统层面
可以通过直接操作 socket 参数来实现。我没有关注里面太多的细节，这纯粹是我的个人解释。以下是我们如何设置 空闲时间 为 30 秒（我们可以通过SetKeepAlivePeriod设置，因为其他参数我们再另外设置），重试时间间隔设置为 5 秒，重试次数设置为 3。我偷了（啊呸，是参考了）上面所引用的文章中的一些代码，多谢。
conn.SetKeepAlive(true) conn.SetKeepAlivePeriod(time.Second * 30) // Getting the File handle of the socket sockFile, sockErr := conn.File() if sockErr == nil { // got socket file handle. Getting descriptor. fd := int(sockFile.Fd()) // Ping amount err := syscall.SetsockoptInt(fd, syscall.IPPROTO_TCP, syscall.TCP_KEEPCNT, 3) if err != nil { Warning("on setting keepalive probe count", err.Error()) } // Retry interval err = syscall.SetsockoptInt(fd, syscall.IPPROTO_TCP, syscall.TCP_KEEPINTVL, 5) if err != nil { Warning("on setting keepalive retry interval", err.Error()) } // don't forget to close the file. No worries, it will *not* cause the connection to close. sockFile.Close() } else { Warning("on setting socket keepalive", sockErr.Error()) }
在这段代码之后的某一行我会写上dataLength, err := conn.Read(readBuf)，这行代码会阻塞直到收到数据或者发生错误。如果是 keepalive 引起的错误，err.Error()将会包含连接超时信息。
关于文件描述符的坑
上面的代码只有在你不频繁调用的前提下才运行良好。在写完这篇文章之后，我以困难模式学习到了一个关于它的小问题。。。
问题就隐藏在Fd [14] 函数调用。我们来看它的实现。
func (f *File) Fd() uintptr {
if f == nil {
return ^(uintptr(0))
}
// If we put the file descriptor into nonblocking mode,
// then set it to blocking mode before we return it,
// because historically we have always returned a descriptor
// opened in blocking mode. The File will continue to work,
// but any blocking operation will tie up a thread.
if f.nonblock {
f.pfd.SetBlocking()
}
return uintptr(f.pfd.Sysfd)
}
如果文件描述符处于非阻塞模式，会将它修改为阻塞模式。根据stackoverflow 的这个回答 [15] ，举例来说，当 Go 增加一个阻塞的系统调用，运行时调度器将该系统调用 所属协程 的 所属系统 线程 从调度池中移出。如果调度池中的系统线程数小于GOMAXPROCS，则会创建新的系统线程。鉴于我的每一个连接都使用一个独立协程，你可以想象一下这个爆炸速度。将很快到达 10000 线程的限制然后 panic。
将它放入独立协程并不好使。
译者yoko注，个人理解此处可做两层解释，如果是像原作者所描述的，每个连接都独占一个协程（直到连接关闭再退出协程），先使用系统调用设置文件描述符属性，再收发数据，那么系统线程会随连接数线性增长。如果是在连接收发数据的协程之前，先弄一个协程处理完文件描述符属性的设置，那么系统调用完成后临时协程结束，线程还是会回收的。但也毕竟不是一种好的模式。
但是有一个方法是可行的。注意，前提是 Go 版本高于 1.11。看以下代码。
//Sets additional keepalive parameters.
//Uses new interfaces introduced in Go1.11, which let us get connection's file descriptor,
//without blocking, and therefore without uncontrolled spawning of threads (not goroutines, actual threads).
func setKeepaliveParameters(conn devconn) {
rawConn, err := conn.SyscallConn()
if err != nil {
Warning("on getting raw connection object for keepalive parameter setting", err.Error())
}
rawConn.Control(
func(fdPtr uintptr) {
// got socket file descriptor. Setting parameters.
fd := int(fdPtr)
//Number of probes.
err := syscall.SetsockoptInt(fd, syscall.IPPROTO_TCP, syscall.TCP_KEEPCNT, 3)
if err != nil {
Warning("on setting keepalive probe count", err.Error())
}
//Wait time after an unsuccessful probe.
err = syscall.SetsockoptInt(fd, syscall.IPPROTO_TCP, syscall.TCP_KEEPINTVL, 3)
if err != nil {
Warning("on setting keepalive retry interval", err.Error())
}
})
}
func deviceProcessor(conn devconn) {
//............
conn.SetKeepAlive(true)
conn.SetKeepAlivePeriod(time.Second * 30)
setKeepaliveParameters(conn)
//............
dataLen, err := conn.Read(readBuf)
//............
}
最新版本的 Go 提供了一些新接口，net.TCPConn实现了SyscallConn [16] ，它使得你可以获取RawConn [17] 对象从而设置参数。你所需要做的就是定义一个函数（就像上面例子中的匿名函数），它接收一个指向文件描述符的参数。这是操作连接中的文件描述符而不造成阻塞调用的方法，可避免出现疯狂创建线程的情况。
总结
网络编程是复杂的。并且时常是系统相关的。这个解决方法只在 Linux 下有用，但是这是一个好的开始。在其他操作系统中有类似的参数，它们只是调用方式不同。
感谢阅读。再见。
本文原始地址：
文中链接
[1]
Notes on TCP keepalive in Go | TheNotExpert:
[2]
SetDeadline: #TCPConn.SetDeadline
[3]
RFC1122: #page-101
[4]
此处3.1.1节:
[5]
net.Conn: #Conn
[6]
TCPConn: #TCPConn
[7]
ListenTCP: #ListenTCP
[8]
AcceptTCP: #TCPListener.AcceptTCP
[9]
Listen: #Listen
[10]
Accept: #TCPListener.Accept
[11]
SetKeepAlive: #TCPConn.SetKeepAlive
[12]
SetKeepAlivePeriod: #TCPConn.SetKeepAlivePeriod
[13]
这篇文章:
[14]
Fd: #File.Fd
[15]
stackoverflow的这个回答:
[16]
SyscallConn: #Conn
[17]
RawConn: #RawConn
