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并发不安全

推荐阅读更多精彩内容