本文共 9526 字，大约阅读时间需要 31 分钟。
本文是使用 golang 实现 redis 系列的第六篇， 将介绍如何实现一个 Pipeline 模式的 Redis 客户端。
本文的完整代码在
通常 TCP 客户端的通信模式都是阻塞式的: 客户端发送请求 -> 等待服务端响应 -> 发送下一个请求。因为需要等待网络传输数据，完成一次请求循环需要等待较多时间。
我们能否不等待服务端响应直接发送下一条请求呢？答案是肯定的。
TCP 作为全双工协议可以同时进行上行和下行通信，不必担心客户端和服务端同时发包会导致冲突。
p.s. 打电话的时候两个人同时讲话就会冲突听不清，只能轮流讲。这种通信方式称为半双工。广播只能由电台发送到收音机不能反向传输，这种方式称为单工。
我们为每一个 tcp 连接分配了一个 goroutine 可以保证先收到的请求先先回复。另一个方面，tcp 协议会保证数据流的有序性，同一个 tcp 连接上先发送的请求服务端先接收，先回复的响应客户端先收到。因此我们不必担心混淆响应所对应的请求。
这种在服务端未响应时客户端继续向服务端发送请求的模式称为 Pipeline 模式。因为减少等待网络传输的时间，Pipeline 模式可以极大的提高吞吐量，减少所需使用的 tcp 链接数。
pipeline 模式的 redis 客户端需要有两个后台协程程负责 tcp 通信，调用方通过 channel 向后台协程发送指令，并阻塞等待直到收到响应，这是一个典型的异步编程模式。
我们先来定义 client 的结构:
type Client struct { conn net.Conn // 与服务端的 tcp 连接 sendingReqs chan *Request // 等待发送的请求 waitingReqs chan *Request // 等待服务器响应的请求 ticker *time.Ticker // 用于触发心跳包的计时器 addr string ctx context.Context cancelFunc context.CancelFunc writing *sync.WaitGroup // 有请求正在处理不能立即停止，用于实现 graceful shutdown}type Request struct { id uint64 // 请求id args [][]byte // 上行参数 reply redis.Reply // 收到的返回值 heartbeat bool // 标记是否是心跳请求 waiting *wait.Wait // 调用协程发送请求后通过 waitgroup 等待请求异步处理完成 err error} 调用者将请求发送给后台协程，并通过 wait group 等待异步处理完成:
func (client *Client) Send(args [][]byte) redis.Reply { request := &Request{ args: args, heartbeat: false, waiting: &wait.Wait{}, } request.waiting.Add(1) client.sendingReqs <- request // 将请求发往处理队列 timeout := request.waiting.WaitWithTimeout(maxWait) // 等待请求处理完成或者超时 if timeout { return reply.MakeErrReply("server time out") } if request.err != nil { return reply.MakeErrReply("request failed: " + err.Error()) } return request.reply} client 的核心部分是后台的读写协程。先从写协程开始:
// 写协程入口func (client *Client) handleWrite() {loop: for { select { case req := <-client.sendingReqs: // 从 channel 中取出请求 client.writing.Add(1) // 未完成请求数+1 client.doRequest(req) // 发送请求 case <-client.ctx.Done(): break loop } }}// 发送请求func (client *Client) doRequest(req *Request) { bytes := reply.MakeMultiBulkReply(req.args).ToBytes() // 序列化 _, err := client.conn.Write(bytes) // 通过 tcp connection 发送 i := 0 for err != nil && i < 3 { // 失败重试 err = client.handleConnectionError(err) if err == nil { _, err = client.conn.Write(bytes) } i++ } if err == nil { client.waitingReqs <- req // 将发送成功的请求放入等待响应的队列 } else { // 发送失败 req.err = err req.waiting.Done() // 结束调用者的等待 client.writing.Done() // 未完成请求数 -1 }} 读协程是我们熟悉的协议解析器模板, 不熟悉的朋友可以到了解更多。
// 收到服务端的响应func (client *Client) finishRequest(reply redis.Reply) { request := <-client.waitingReqs // 取出等待响应的 request request.reply = reply if request.waiting != nil { request.waiting.Done() // 结束调用者的等待 } client.writing.Done() // 未完成请求数-1}// 读协程是个 RESP 协议解析器，不熟悉的朋友可以func (client *Client) handleRead() error { reader := bufio.NewReader(client.conn) downloading := false expectedArgsCount := 0 receivedCount := 0 msgType := byte(0) // first char of msg var args [][]byte var fixedLen int64 = 0 var err error var msg []byte for { // read line if fixedLen == 0 { // read normal line msg, err = reader.ReadBytes('\n') if err != nil { if err == io.EOF || err == io.ErrUnexpectedEOF { logger.Info("connection close") } else { logger.Warn(err) } return errors.New("connection closed") } if len(msg) == 0 || msg[len(msg)-2] != '\r' { return errors.New("protocol error") } } else { // read bulk line (binary safe) msg = make([]byte, fixedLen+2) _, err = io.ReadFull(reader, msg) if err != nil { if err == io.EOF || err == io.ErrUnexpectedEOF { return errors.New("connection closed") } else { return err } } if len(msg) == 0 || msg[len(msg)-2] != '\r' || msg[len(msg)-1] != '\n' { return errors.New("protocol error") } fixedLen = 0 } // parse line if !downloading { // receive new response if msg[0] == '*' { // multi bulk response // bulk multi msg expectedLine, err := strconv.ParseUint(string(msg[1:len(msg)-2]), 10, 32) if err != nil { return errors.New("protocol error: " + err.Error()) } if expectedLine == 0 { client.finishRequest(&reply.EmptyMultiBulkReply{}) } else if expectedLine > 0 { msgType = msg[0] downloading = true expectedArgsCount = int(expectedLine) receivedCount = 0 args = make([][]byte, expectedLine) } else { return errors.New("protocol error") } } else if msg[0] == '$' { // bulk response fixedLen, err = strconv.ParseInt(string(msg[1:len(msg)-2]), 10, 64) if err != nil { return err } if fixedLen == -1 { // null bulk client.finishRequest(&reply.NullBulkReply{}) fixedLen = 0 } else if fixedLen > 0 { msgType = msg[0] downloading = true expectedArgsCount = 1 receivedCount = 0 args = make([][]byte, 1) } else { return errors.New("protocol error") } } else { // single line response str := strings.TrimSuffix(string(msg), "\n") str = strings.TrimSuffix(str, "\r") var result redis.Reply switch msg[0] { case '+': result = reply.MakeStatusReply(str[1:]) case '-': result = reply.MakeErrReply(str[1:]) case ':': val, err := strconv.ParseInt(str[1:], 10, 64) if err != nil { return errors.New("protocol error") } result = reply.MakeIntReply(val) } client.finishRequest(result) } } else { // receive following part of a request line := msg[0 : len(msg)-2] if line[0] == '$' { fixedLen, err = strconv.ParseInt(string(line[1:]), 10, 64) if err != nil { return err } if fixedLen <= 0 { // null bulk in multi bulks args[receivedCount] = []byte{} receivedCount++ fixedLen = 0 } } else { args[receivedCount] = line receivedCount++ } // if sending finished if receivedCount == expectedArgsCount { downloading = false // finish downloading progress if msgType == '*' { reply := reply.MakeMultiBulkReply(args) client.finishRequest(reply) } else if msgType == '$' { reply := reply.MakeBulkReply(args[0]) client.finishRequest(reply) } // finish reply expectedArgsCount = 0 receivedCount = 0 args = nil msgType = byte(0) } } }} 最后编写 client 的构造器和启动异步协程的代码:
func MakeClient(addr string) (*Client, error) { conn, err := net.Dial("tcp", addr) if err != nil { return nil, err } ctx, cancel := context.WithCancel(context.Background()) return &Client{ addr: addr, conn: conn, sendingReqs: make(chan *Request, chanSize), waitingReqs: make(chan *Request, chanSize), ctx: ctx, cancelFunc: cancel, writing: &sync.WaitGroup{}, }, nil}func (client *Client) Start() { client.ticker = time.NewTicker(10 * time.Second) go client.handleWrite() go func() { err := client.handleRead() logger.Warn(err) }() go client.heartbeat()} 关闭 client 的时候记得等待请求完成:
func (client *Client) Close() { // 先阻止新请求进入队列 close(client.sendingReqs) // 等待处理中的请求完成 client.writing.Wait() // 释放资源 _ = client.conn.Close() // 关闭与服务端的连接，连接关闭后读协程会退出 client.cancelFunc() // 使用 context 关闭读协程 close(client.waitingReqs) // 关闭队列} 测试一下:
func TestClient(t *testing.T) { client, err := MakeClient("localhost:6379") if err != nil { t.Error(err) } client.Start() result = client.Send([][]byte{ []byte("SET"), []byte("a"), []byte("a"), }) if statusRet, ok := result.(*reply.StatusReply); ok { if statusRet.Status != "OK" { t.Error("`set` failed, result: " + statusRet.Status) } } result = client.Send([][]byte{ []byte("GET"), []byte("a"), }) if bulkRet, ok := result.(*reply.BulkReply); ok { if string(bulkRet.Arg) != "a" { t.Error("`get` failed, result: " + string(bulkRet.Arg)) } }} 转载地址：http://nxqzz.baihongyu.com/