6.Thrift指南 thrift go源码解析 1

---

前言： 一切从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并发不安全