老师源码中的Handle函数是监听channel，拿到一个payload，exec完，写回一个结果到客户端，然后再取channel中下一个payload，再exec，再写回客户端。
我做了一个测试，在execSet中睡眠了一秒，然后在tcp测试工具中发送了一百个*3\r\n$3\r\nset\r\n$3\r\nkey\r\n$5\r\nvalue\r\n 请求
结果是每一个请求的回复都隔了一秒，也就是100个请求等一百个回复等了100秒。

func execSet(db *DB, args [][]byte) resp.Reply {
	time.Sleep(time.Second) //睡眠一秒
	key := string(args[0])
	value := args[1]
	entity := &database.DataEntity{
		Data: value,
	}
	db.PutEntity(key, entity)
	return &reply.OkReply{}
}

//老师源码
func (h *RespHandler) Handle(ctx context.Context, conn net.Conn) {
	if h.closing.Get() {
		// closing handler refuse new connection
		_ = conn.Close()
	}

	client := connection.NewConn(conn)
	h.activeConn.Store(client, 1)

	ch := parser.ParseStream(conn)
	for payload := range ch {
		if payload.Err != nil {
			if payload.Err == io.EOF ||
				payload.Err == io.ErrUnexpectedEOF ||
				strings.Contains(payload.Err.Error(), "use of closed network connection") {
				// connection closed
				h.closeClient(client)
				logger.Info("connection closed: " + client.RemoteAddr().String())
				return
			}
			// protocol err
			errReply := reply.MakeErrReply(payload.Err.Error())
			err := client.Write(errReply.ToBytes())
			if err != nil {
				h.closeClient(client)
				logger.Info("connection closed: " + client.RemoteAddr().String())
				return
			}
			continue
		}
		if payload.Data == nil {
			logger.Error("empty payload")
			continue
		}
		r, ok := payload.Data.(*reply.MultiBulkReply)
		if !ok {
			logger.Error("require multi bulk reply")
			continue
		}
		result := h.db.Exec(client, r.Args)
		if result != nil {
			_ = client.Write(result.ToBytes())
		} else {
			_ = client.Write(unknownErrReplyBytes)
		}
	}
}

我的改动是，handle函数在遍历channel的时候，每拿到一个payload，开一个协程去做exec（当然如果协程数量太多，可以设置一个协程数量最大值，用队列去分配），结果是100个set请求，收到100个回复只需要不到两秒钟的时间

func (h *RespHandler) Handle(ctx context.Context, conn net.Conn) {

	//1 判断处理器是否处于关闭状态，如果是则拒绝新的连接
	if h.closing.Get() {
		// closing handler refuse new connection
		conn.Close()
	}
	//2 将原始连接包装成redis连接,并将新连接加入连接字典
	println(conn.RemoteAddr())
	client := connection.NewConn(conn)
	h.activeConn.Store(client, 1)

	//3 将redis连接送给解析器，并监听数据通道

	ch := parser.ParseStream(conn)

	for payload := range ch {
		go func() {
			h.exec(payload, client)
		}()
	}

}
//将原来的exec代码片段抽出来做一个函数，当然需要把代码中的continue语句都删掉，因为已经不在循环里
func (h *RespHandler) exec(payload *parser.Payload, client *connection.Connection) {

	if payload.Err != nil {
		if payload.Err == io.EOF ||
			payload.Err == io.ErrUnexpectedEOF ||
			strings.Contains(payload.Err.Error(), "use of closed network connection") {
			// connection closed
			h.closeClient(client)
			logger.Info("connection closed: " + client.RemoteAddr().String())
			return
		}
		// protocol err
		errReply := reply.MakeErrReply(payload.Err.Error())
		err := client.Write(errReply.ToBytes())
		if err != nil {
			h.closeClient(client)
			logger.Info("connection closed: " + client.RemoteAddr().String())
			return
		}

	}
	if payload.Data == nil {
		logger.Error("empty payload")

	}
	r, ok := payload.Data.(*reply.MultiBulkReply)
	if !ok {
		logger.Error("require multi bulk reply")

	}
	result := h.mdb.Exec(client, r.Args)
	if result != nil {
		client.Write(result.ToBytes())
	} else {
		client.Write(unknownErrReplyBytes)
	}
}

老师你觉得这样可行吗？