前言： 一切从thrift go demo服务端开始...
⚠️thrift go源码版本 0.11.0
1.从服务端demo开始
2.源码入口
1.从服务端demo开始
1.1 服务端demo代码的工作非常简单，主要做了两步：
- 一、初始化一个SimpleServer类实例
- 二、运行实例方法Serve()
这里与我们平常做法一致，通过一个结构来组织程序，类似于控制层c
func main() {
// ....这里节选自 【3.Thrift指南 实战go服务端】
server := thrift.NewTSimpleServer2(processor, transport)
server.Serve()
}
2.源码入口
2.1 首先阅读TSimpleServer结构，文件头、方法注释 (thrift/simple_server.go)
通过结构定义以及相关字段对整个TSimpleServer有一个初步的认识。
通过注释对文件、方法用途有一个了解。
# 这是一个典型的TSimpleServer服务，因为它在接收套接字后不会阻塞。
# 它更像一个TThreadedServer服务，可以在不同的goroutine中处理连接。
# 如果在golang客户端实现连接池之类的东西就可以工作了。
/*
* This is not a typical TSimpleServer as it is not blocked after accept a socket.
* It is more like a TThreadedServer that can handle different connections in different goroutines.
* This will work if golang user implements a conn-pool like thing in client side.
*/
type TSimpleServer struct {
closed int32 # 服务状态标识
wg sync.WaitGroup # 等待goroutine完成必备
mu sync.Mutex # 锁
processorFactory TProcessorFactory
serverTransport TServerTransport # serve具体实现
inputTransportFactory TTransportFactory
outputTransportFactory TTransportFactory
inputProtocolFactory TProtocolFactory
outputProtocolFactory TProtocolFactory
}
closed、wg、mu定义简单具体，一目了然
*Factory采用接口形式组织，是常见的工厂模式设计
2.2 .Serve()这个方法主要做了两件事：
- 一、p.serverTransport.Listen() 开始Listen
- 二、p.AcceptLoop() 开始accept阻塞，等待客户端连接
func (p *TSimpleServer) Serve() error {
err := p.Listen()
if err != nil {
return err
}
p.AcceptLoop()
return nil
}
func (p *TSimpleServer) Listen() error {
return p.serverTransport.Listen()
}
func (p *TSimpleServer) AcceptLoop() error {
for {
// 这里调用server_socket.go下TServerSocket类的方法
// 实质为开始Accept阻塞，等待客户端连接
client, err := p.serverTransport.Accept()
if err != nil {
return err
}
// ?? 黑人问号.jpg
p.mu.Lock()
// 严谨的if，获取当前服务端状态标识，确保服务关闭后不会处理新任务
if atomic.LoadInt32(&p.closed) != 0 {
return nil
}
// 严谨的if
if client != nil {
// p.wg.* 确保停止服务时，所有业务goroutine都可以正常执行完毕
p.wg.Add(1)
// 正如文件头描述的那般,
// 不同的goroutine处理不同的client
go func() {
defer p.wg.Done()
// 具体的业务处理，下一章节
if err := p.processRequests(client); err != nil {
log.Println("error processing request:", err)
}
}()
}
p.mu.Unlock()
}
}
func (p *TSimpleServer) Stop() error {
// 这个加锁，atomic.LoadInt32和atomic.StoreInt32操作并发不安全
p.mu.Lock()
defer p.mu.Unlock()
// 严谨的if，读取服务标识
if atomic.LoadInt32(&p.closed) != 0 {
return nil
}
// 关闭服务（由此可见通过 0，1来标识服务，那用i8岂不美哉, hahah~）
atomic.StoreInt32(&p.closed, 1)
// 连接中断，可选实现
p.serverTransport.Interrupt()
p.wg.Wait()
return nil
}
上面注释了每一行代码的作用，下面整理了其中的关键点：
- 采用wg等待业务处理完毕退出主程序。
- 采用goroutine来实现业务处理，提高性能。
- 采用锁确保atomic.LoadInt32和atomic.StoreInt32原子操作并发安全。
- AcceptLoop()的锁是否有必要？if判断的必要性？
- Stop()中的p.serverTransport.Interrupt() 的中断作用何在？（server_transport.go注释定义）
总结
TSimpleServer结构、方法的定义非常简单清晰明了，严谨的if判断，不同goroute处理不同业务，实现高性能的同时又缩减了代码。主要得益于go语法，以及工厂设计模式对复杂的业务逻辑的简化，TSimpleServer服务只需要组织起结构，这其中的减法有助于我们程序扩展性更强，也是我们需要学习的地方。
但是关键点中的疑问，我们下下章再见👋...
附录：
go 等待所以goroutine处理完毕，才退出主程序
go sync/atomic包Load和Store并发不安全
