Go语言学习之9网络协议TCP、Redis与聊天室

原作者: [db:作者] 来自: [db:来源] 收藏邀请

主要内容

1. Tcp编程
2. redis使用

1. Tcp编程

（1）简介

Golang是谷歌设计开发的语言，在Golang的设计之初就把高并发的性能作为Golang的主要特性之一，也是面向大规模后端服务程序。在服务器端网络通信是必不可少的也是至关重要的一部分。Golang内置的包例如net、net/http中的底层就是对TCP socket方法的封装。

TCP简介：

1 Golang是谷歌设计开发的语言，在Golang的设计之初就把高并发的性能作为Golang的主要特性之一，也是面向大规模后端服务程序。在服务器端网络通信是必不可少的也是至关重要的一部分。Golang内置的包例如net、net/http中的底层就是对TCP socket方法的封装。
2 网络编程方面，我们最常用的就是tcp socket编程了，在posix标准出来后，socket在各大主流OS平台上都得到了很好的支持。关于tcp programming，最好的资料莫过于W. Richard Stevens 的网络编程圣经《UNIX网络 编程 卷1：套接字联网API》 了，书中关于tcp socket接口的各种使用、行为模式、异常处理讲解的十分细致。

TCP简介

Go是自带runtime的跨平台编程语言，Go中暴露给语言使用者的tcp socket api是建立OS原生tcp socket接口之上的。由于Go runtime调度的需要，golang tcp socket接口在行为特点与异常处理方面与OS原生接口有着一些差别。

（2）模型

从tcp socket诞生后，网络编程架构模型也几经演化，大致是：“每进程一个连接” –> “每线程一个连接” –> “Non-Block + I/O多路复用(linux epoll/windows iocp/freebsd darwin kqueue/solaris Event Port)”。伴随着模型的演化，服务程序愈加强大，可以支持更多的连接，获得更好的处理性能

目前主流web server一般均采用的都是”Non-Block + I/O多路复用”（有的也结合了多线程、多进程）。不过I/O多路复用也给使用者带来了不小的复杂度，以至于后续出现了许多高性能的I/O多路复用框架，比如libevent、libev、libuv等，以帮助开发者简化开发复杂性，降低心智负担。不过Go的设计者似乎认为I/O多路复用的这种通过回调机制割裂控制流的方式依旧复杂，且有悖于“一般逻辑”设计，为此Go语言将该“复杂性”隐藏在Runtime中了：Go开发者无需关注socket是否是 non-block的，也无需亲自注册文件描述符的回调，只需在每个连接对应的goroutine中以“block I/O”的方式对待socket处理即可，这可以说大大降低了开发人员的心智负担。一个典型的Go server端程序大致如下：

 1 //go-tcpsock/server.go
 2 func HandleConn(conn net.Conn) {
 3     defer conn.Close()
 4 
 5     for {
 6         // read from the connection
 7         // ... ...
 8         // write to the connection
 9         //... ...
10     }
11 }
12 
13 func main() {
14     listen, err := net.Listen("tcp", ":8888")
15     if err != nil {
16         fmt.Println("listen error: ", err)
17         return
18     }
19 
20     for {
21         conn, err := listen.Accept()
22         if err != nil {
23             fmt.Println("accept error: ", err)
24             break
25         }
26 
27         // start a new goroutine to handle the new connection
28         go HandleConn(conn)
29     }
30 }

Go server编程

（重点）用户层眼中看到的goroutine中的“block socket”，实际上是通过Go runtime中的netpoller通过Non-block socket + I/O多路复用机制“模拟”出来的，真实的underlying socket实际上是non-block的，只是runtime拦截了底层socket系统调用的错误码，并通过netpoller和goroutine 调度让goroutine“阻塞”在用户层得到的Socket fd上。比如：当用户层针对某个socket fd发起read操作时，如果该socket fd中尚无数据，那么runtime会将该socket fd加入到netpoller中监听，同时对应的goroutine被挂起，直到runtime收到socket fd 数据ready的通知，runtime才会重新唤醒等待在该socket fd上准备read的那个Goroutine。而这个过程从Goroutine的视角来看，就像是read操作一直block在那个socket fd上似的。

关于netpoller可以看下这为博主博客：http://www.opscoder.info/golang_netpoller.html

（3）TCP连接的建立

众所周知，TCP Socket的连接的建立需要经历客户端和服务端的三次握手的过程。连接建立过程中，服务端是一个标准的Listen + Accept的结构(可参考上面的代码)，而在客户端Go语言使用net.Dial()或net.DialTimeout()进行连接建立。

服务端的处理流程： a. 监听端口 b. 接收客户端的链接 c. 创建goroutine，处理该链接

客户端的处理流程： a. 建立与服务端的链接 b. 进行数据收发 c. 关闭链接

通过客户端可服务端实现一个简单的聊天系统？

客户端：

 1 package main
 2 
 3 import (
 4     "bufio"
 5     "fmt"
 6     "net"
 7     "os"
 8     "strings"
 9 )
10 
11 func main() {
12     fmt.Println("start client...")
13     conn, err := net.Dial("tcp", "localhost:50000")
14     if err != nil {
15         fmt.Println("Error dialing", err.Error())
16         return
17     }
18 
19     defer conn.Close()
20     inputReader := bufio.NewReader(os.Stdin)
21     for {
22         input, _ := inputReader.ReadString('\n')
23         trimmedInput := strings.Trim(input, "\r\n")
24         if trimmedInput == "Q" {
25             return
26         }
27         _, err = conn.Write([]byte(trimmedInput))
28         if err != nil {
29             return
30         }
31     }
32 }

client.go

服务端：

 1 package main
 2 
 3 import (
 4     "fmt"
 5     "net"
 6     "io"
 7 )
 8 func main() {
 9     fmt.Println("start server...")
10     listen, err := net.Listen("tcp", "0.0.0.0:50000")
11     if err != nil {
12         fmt.Println("listen failed, err:", err)
13         return
14     }
15     for {
16         conn, err := listen.Accept()
17         if err != nil {
18             fmt.Println("accept failed, err:", err)
19             continue
20         }
21         go process(conn)
22     }
23 }
24 
25 func process(conn net.Conn) {
26     defer conn.Close()
27 
28     for {
29         buf := make([]byte, 10)
30         _, err := conn.Read(buf)
31 
32         if err == io.EOF {  //当客户端断开的时候就无法读到数据
33             fmt.Println("read end")
34             return
35         }
36 
37         if err != nil {
38             fmt.Println("read err:", err)
39             return
40         }
41         fmt.Println("read: ", string(buf))
42     }
43 }

server.go

阻塞Dial：

1 conn, err := net.Dial("tcp", "www.baidu.com:80")
2 if err != nil {
3     //handle error
4 }
5 //read or write on conn

阻塞Dial

超时机制的Dial：

1 conn, err := net.DialTimeout("tcp", "www.baidu.com:80", 2*time.Second)
2 if err != nil {
3     //handle error
4 }
5 //read or write on conn

超时Dial

对于客户端而言，连接的建立会遇到如下几种情形：

网络不可达或对方服务未启动

如果传给Dial的Addr是可以立即判断出网络不可达，或者Addr中端口对应的服务没有启动，端口未被监听，Dial会几乎立即返回错误，比如：

 1 package main 
 2 
 3 import (
 4     "net"
 5     "log"
 6 )
 7 
 8 func main() {
 9     log.Println("begin dial...")
10     conn, err := net.Dial("tcp", ":8888")
11     if err != nil {
12         log.Println("dial error:", err)
13         return
14     }
15     defer conn.Close()
16     log.Println("dial ok")
17 }

网络不可达或对方服务未启动

如果本机8888端口未有服务程序监听，那么执行上面程序，Dial会很快返回错误：

注：在Centos6.5上测试，下同。

对方服务的listen backlog满

还有一种场景就是对方服务器很忙，瞬间有大量client端连接尝试向server建立，server端的listen backlog队列满，server accept不及时((即便不accept，那么在backlog数量范畴里面，connect都会是成功的，因为new conn已经加入到server side的listen queue中了，accept只是从queue中取出一个conn而已)，这将导致client端Dial阻塞。我们还是通过例子感受Dial的行为特点：

服务端代码：

 1 package main 
 2 
 3 import (
 4     "net"
 5     "log"
 6     "time"
 7 )
 8 
 9 func main() {
10     l, err := net.Listen("tcp", ":8888")
11     if err != nil {
12         log.Println("error listen:", err)
13         return
14     }
15     defer l.Close()
16     log.Println("listen ok")
17 
18     var i int
19     for {
20         time.Sleep(time.Second * 10)
21         if _, err := l.Accept(); err != nil {
22             log.Println("accept error:", err)
23             break
24         }
25         i++
26         log.Printf("%d: accept a new connection\n", i)
27     }
28 }

server.go

客户端代码：

 1 package main 
 2 
 3 import (
 4     "net"
 5     "log"
 6     "time"
 7 )
 8 
 9 func establishConn(i int) net.Conn {
10     conn, err := net.Dial("tcp", ":8888")
11     if err != nil {
12         log.Printf("%d: dial error: %s", i, err)
13         return nil
14     }
15     log.Println(i, ":connect to server ok")
16     return conn
17 }
18 
19 func main() {
20     var sl []net.Conn
21 
22     for i := 1; i < 1000; i++ {
23         conn := establishConn(i)
24         if conn != nil {
25             sl = append(sl, conn)
26         }
27     }
28 
29     time.Sleep(time.Second * 10000)
30 }

client.go

经过测试在Client初始时成功地一次性建立了131个连接，然后后续每阻塞近1s才能成功建立一条连接。也就是说在server端 backlog满时(未及时accept)，客户端将阻塞在Dial上，直到server端进行一次accept。

如果server一直不accept，client端会一直阻塞么？我们去掉accept后的结果是：在Darwin下，client端会阻塞大约1分多钟才会返回timeout。而如果server运行在ubuntu 14.04上，client似乎一直阻塞，我等了10多分钟依旧没有返回。阻塞与否看来与server端的网络实现和设置有关。

注：在Centos6.5上测试，发现注释掉server端的accept，client一次建立131个连接后，后面还会每隔1s建立一个链接。

网络延迟较大，Dial阻塞并超时

如果网络延迟较大，TCP握手过程将更加艰难坎坷（各种丢包），时间消耗的自然也会更长。Dial这时会阻塞，如果长时间依旧无法建立连接，则Dial也会返回“ getsockopt: operation timed out”错误。

在连接建立阶段，多数情况下，Dial是可以满足需求的，即便阻塞一小会儿。但对于某些程序而言，需要有严格的连接时间限定，如果一定时间内没能成功建立连接，程序可能会需要执行一段“异常”处理逻辑，为此我们就需要DialTimeout了。下面的例子将Dial的最长阻塞时间限制在2s内，超出这个时长，Dial将返回timeout error：

 1 package main 
 2 
 3 import (
 4     "net"
 5     "log"
 6     "time"
 7 )
 8 
 9 func main() {
10     log.Println("begin dial...")
11     conn, err := net.DialTimeout("tcp", "192.168.30.134:8888", 2*time.Second)
12     if err != nil {
13         log.Println("dial error:", err)
14         return
15     }
16     defer conn.Close()
17     log.Println("dial ok")
18 }

client_timeout.go

执行结果如下，需要模拟一个网络延迟大的环境：

1 $go run client_timeout.go
2 2015/11/17 09:28:34 begin dial...
3 2015/11/17 09:28:36 dial error: dial tcp 104.236.176.96:80: i/o timeout

（4）Socket读写

连接建立起来后，我们就要在conn上进行读写，以完成业务逻辑。前面说过Go runtime隐藏了I/O多路复用的复杂性。语言使用者只需采用goroutine+Block I/O的模式即可满足大部分场景需求。Dial成功后，方法返回一个Conn接口类型变量值。

客户端Dial建立连接：

func Dial(network, address string) (Conn, error)

 1 type Conn interface {
 2         // Read reads data from the connection.
 3         // Read can be made to time out and return an Error with Timeout() == true
 4         // after a fixed time limit; see SetDeadline and SetReadDeadline.
 5         Read(b []byte) (n int, err error)
 6 
 7         // Write writes data to the connection.
 8         // Write can be made to time out and return an Error with Timeout() == true
 9         // after a fixed time limit; see SetDeadline and SetWriteDeadline.
10         Write(b []byte) (n int, err error)
11 
12         // Close closes the connection.
13         // Any blocked Read or Write operations will be unblocked and return errors.
14         Close() error
15 
16         // LocalAddr returns the local network address.
17         LocalAddr() Addr
18 
19         // RemoteAddr returns the remote network address.
20         RemoteAddr() Addr
21 
22         // SetDeadline sets the read and write deadlines associated
23         // with the connection. It is equivalent to calling both
24         // SetReadDeadline and SetWriteDeadline.
25         //
26         // A deadline is an absolute time after which I/O operations
27         // fail with a timeout (see type Error) instead of
28         // blocking. The deadline applies to all future and pending
29         // I/O, not just the immediately following call to Read or
30         // Write. After a deadline has been exceeded, the connection
31         // can be refreshed by setting a deadline in the future.
32         //
33         // An idle timeout can be implemented by repeatedly extending
34         // the deadline after successful Read or Write calls.
35         //
36         // A zero value for t means I/O operations will not time out.
37         SetDeadline(t time.Time) error
38 
39         // SetReadDeadline sets the deadline for future Read calls
40         // and any currently-blocked Read call.
41         // A zero value for t means Read will not time out.
42         SetReadDeadline(t time.Time) error
43 
44         // SetWriteDeadline sets the deadline for future Write calls
45         // and any currently-blocked Write call.
46         // Even if write times out, it may return n > 0, indicating that
47         // some of the data was successfully written.
48         // A zero value for t means Write will not time out.
49         SetWriteDeadline(t time.Time) error
50 }

Conn接口

服务器端Listen监听客户端连接：

func Listen(network, address string) (Listener, error)

 1 type Listener interface {
 2         // Accept waits for and returns the next connection to the listener.
 3         Accept() (Conn, error)
 4 
 5         // Close closes the listener.
 6         // Any blocked Accept operations will be unblocked and return errors.
 7         Close() error
 8 
 9         // Addr returns the listener's network address.
10         Addr() Addr
11 }

Listener 接口

从Conn接口中有Read，Write，Close等方法。

1）conn.Read的特点

Socket中无数据

连接建立后，如果对方未发送数据到socket，接收方(Server)会阻塞在Read操作上，这和前面提到的“模型”原理是一致的。执行该Read操作的goroutine也会被挂起。runtime会监视该socket，直到其有数据才会重新调度该socket对应的Goroutine完成read。例子对应的代码文件：go-tcpsock/read_write下的client1.go和server1.go。

 1 package main
 2 
 3 import (
 4     "log"
 5     "net"
 6     "time"
 7 )
 8 
 9 func main() {
10     log.Println("begin dial...")
11     conn, err := net.Dial("tcp", ":8888")
12     if err != nil {
13         log.Println("dial error:", err)
14         return
15     }
16     defer conn.Close()
17     log.Println("dial ok")
18     time.Sleep(time.Second * 10000)
19 }

client1.go

 1 //server.go
 2 
 3 package main
 4 
 5 import (
 6     "log"
 7     "net"
 8 )
 9 
10 func handleConn(c net.Conn) {
11     defer c.Close()
12     for {
13         // read from the connection
14         var buf = make([]byte, 10)
15         log.Println("start to read from conn")
16         n, err := c.Read(buf)
17         if err != nil {
18             log.Println("conn read error:", err)
19             return
20         }
21         log.Printf("read %d bytes, content is %s\n", n, string(buf[:n]))
22     }
23 }
24 
25 func main() {
26     l, err := net.Listen("tcp", ":8888")
27     if err != nil {
28         log.Println("listen error:", err)
29         return
30     }
31 
32     for {
33         c, err := l.Accept()
34         if err != nil {
35             log.Println("accept error:", err)
36             break
37         }
38         // start a new goroutine to handle
39         // the new connection.
40         log.Println("accept a new connection")
41         go handleConn(c)
42     }
43 }