Go / 系统课时

实现连接处理与消息分发

实现连接处理与消息分发

一个可用的 TCP 服务不能只做到“收一条、回一条”,还要明确谁负责解码、谁执行业务、谁写回,以及并发上限在哪里。本课把连接读循环与固定大小的 Worker 池组合起来:单连接保持有序,全局业务处理保持有界并发。

学习目标

  • 组织“读取帧 → 解码 → 业务处理 → 编码写回”的连接处理链路
  • 用固定 Worker 池限制全局业务并发,避免请求量直接膨胀为 Goroutine 数量
  • 理解单连接串行模型的顺序保证、背压位置和适用边界

将单连接顺序和全局并发分开

最容易失控的做法,是每读到一条消息就直接 go handle(msg)。这样单个连接可以无限制造 Goroutine,响应还可能乱序。更稳妥的基础模型是:每个连接只有一个读循环;解码后把任务提交到全局有界队列;Worker 完成业务后,连接 Goroutine 再负责写回。

连接处理与消息分发的数据流

这个模型把“连接数”和“业务并发数”解耦。即使同时存在很多连接,真正并行执行的业务任务仍由 Worker 数量决定;队列满时,提交动作会阻塞,自然把压力传回连接读循环。

实现有界消息分发

下面的可运行示例使用 4 字节大端长度头定义消息帧,并用 net.Pipe 在一个进程内模拟客户端与服务端。Worker 池大小固定为 2,而每个连接在拿到当前消息结果后才继续读取下一帧,因此不会出现同连接响应乱序。

go
package main

import (
	"bufio"
	"encoding/binary"
	"fmt"
	"io"
	"net"
	"strings"
	"sync"
)

type job struct {
	payload []byte
	result  chan []byte
}

type workerPool struct {
	jobs chan job
	wg   sync.WaitGroup
}

func newWorkerPool(n int) *workerPool {
	p := &workerPool{jobs: make(chan job, n)}
	for i := 0; i < n; i++ {
		p.wg.Add(1)
		go func() {
			defer p.wg.Done()
			for j := range p.jobs {
				j.result <- handle(j.payload)
			}
		}()
	}
	return p
}

func (p *workerPool) Close() {
	close(p.jobs)
	p.wg.Wait()
}

func handle(payload []byte) []byte {
	if string(payload) == "ping" {
		return []byte("PONG")
	}
	return []byte(strings.ToUpper(string(payload)))
}

func serveConn(conn net.Conn, pool *workerPool) {
	defer conn.Close()
	reader := bufio.NewReader(conn)

	for {
		payload, err := readFrame(reader)
		if err != nil {
			if err != io.EOF {
				fmt.Println("server read:", err)
			}
			return
		}

		// 缓冲 1 个结果,避免 Worker 因连接切换时机而被无意义阻塞。
		result := make(chan []byte, 1)
		pool.jobs <- job{payload: payload, result: result}

		// 等待当前消息完成再写回,保留单连接请求与响应顺序。
		if err := writeFrame(conn, <-result); err != nil {
			fmt.Println("server write:", err)
			return
		}
	}
}

func readFrame(r io.Reader) ([]byte, error) {
	var header [4]byte
	if _, err := io.ReadFull(r, header[:]); err != nil {
		return nil, err
	}

	n := binary.BigEndian.Uint32(header[:])
	if n > 1024 {
		return nil, fmt.Errorf("frame too large: %d", n)
	}

	payload := make([]byte, n)
	_, err := io.ReadFull(r, payload)
	return payload, err
}

func writeFrame(w io.Writer, payload []byte) error {
	var header [4]byte
	binary.BigEndian.PutUint32(header[:], uint32(len(payload)))

	if _, err := w.Write(header[:]); err != nil {
		return err
	}
	_, err := w.Write(payload)
	return err
}

func main() {
	pool := newWorkerPool(2)
	defer pool.Close()

	serverSide, clientSide := net.Pipe()
	go serveConn(serverSide, pool)

	if err := writeFrame(clientSide, []byte("ping")); err != nil {
		panic(err)
	}

	reply, err := readFrame(clientSide)
	if err != nil {
		panic(err)
	}
	fmt.Println("client:", string(reply))
	clientSide.Close()
}

预期输出:

text
client: PONG

这里的 1024 字节是示例的单帧上限。生产服务应按协议设置合理的最大帧长,否则攻击者可以伪造超大长度字段,诱导进程申请大量内存。

识别背压和顺序边界

固定 Worker 数只限制“正在执行业务”的并发,不等于系统永远不会堆积。jobs 的容量决定短时突发能缓冲多少任务;当队列写满,pool.jobs <- job{...} 阻塞,当前连接停止继续读,这就是最直接的背压点。

该实现还刻意让单连接一次只保留一个在途请求,因此顺序最容易推理。代价是某个慢业务会阻塞该连接后续消息。如果协议允许多路复用或乱序响应,就需要给消息增加请求 ID,并把“读”和“写”拆成独立协程,再用有界写队列统一串行写 socket。

什么时候需要更复杂的调度

当业务处理很快、协议要求按序响应时,“单连接串行 + 全局 Worker 池”通常足够稳健。若出现长任务、优先级请求或单连接高吞吐需求,应先明确是否允许乱序,再决定是否增加每连接并发、独立写队列或分级 Worker 池。

无论模型怎样扩展,都应保留三个硬边界:最大帧长、全局业务并发上限和有界队列容量。只要这三个边界可观测且可配置,连接数上升时就更容易判断瓶颈究竟在读取、排队、业务还是写回阶段。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

实现连接处理与消息分发

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通