如何在Uber FX中实现后台进程的优雅关闭？

假设在Uber FX应用中有一个需要执行轮询外部API等后台活动的服务，通过启动goroutine运行后台任务时，如何正确停止它们？以下是一种可行的实现示例：

package main

import (
    "context"
    "log"
    "sync"
    "time"

    "go.uber.org/fx"
)

type AwesomeService struct {
    // 后台进程使用的context
    bg context.Context
    // 触发后台进程停止的cancel函数
    cancel context.CancelFunc
    // 等待后台进程优雅退出的WaitGroup
    wg *sync.WaitGroup
}

func New(lc fx.Lifecycle) *AwesomeService {
    bg, cancel := context.WithCancel(context.Background())
    service := &AwesomeService{
        bg:     bg,
        cancel: cancel,
        wg:     new(sync.WaitGroup),
    }

    lc.Append(fx.Hook{
        OnStart: service.start,
        OnStop:  service.stop,
    })
    return service
}

func (s *AwesomeService) start(_ context.Context) error {
    s.runBackgroundProcess()
    log.Println("Start done")
    return nil
}

func (s *AwesomeService) stop(_ context.Context) error {
    s.cancel()
    s.wg.Wait()
    log.Println("Stop done")
    return nil
}

// runBackgroundProcess 持续执行任务直到context被取消
func (s *AwesomeService) runBackgroundProcess() {
    s.wg.Add(1)
    go func() {
        defer s.wg.Done()
        for {
            select {
            case <-s.bg.Done():
                return
            case <-time.After(1 * time.Second):
                log.Println("Working...")
            }
        }
    }()
}

func main() {
    fx.New(
        fx.Provide(New),
        fx.Invoke(func(*AwesomeService) {}),
    ).Run()
}

相关说明 #

• 服务通过fx.Lifecycle钩子绑定到应用生命周期，实现启动和停止的回调。
• 不能依赖OnStart/OnStop方法传入的context，这些context仅对应启停操作本身的生命周期，而非整个应用的后台任务生命周期。

疑问解答 #

1. 示例跟踪后台任务的方式繁琐，且把context存在结构体里是反模式，有没有简化方案？ #

确实可以简化，核心思路是避免在结构体中存储context和cancel函数，将生命周期相关逻辑内聚处理：

可以将启动、停止逻辑直接整合在服务初始化过程中，让context的作用域与goroutine直接绑定，而非存在结构体中。优化后的示例如下：

package main

import (
    "context"
    "log"
    "sync"
    "time"

    "go.uber.org/fx"
)

type AwesomeService struct{}

func New(lc fx.Lifecycle) *AwesomeService {
    var wg sync.WaitGroup

    lc.Append(fx.Hook{
        OnStart: func(ctx context.Context) error {
            bg, cancel := context.WithCancel(context.Background())
            // 将停止逻辑绑定到生命周期
            lc.Append(fx.Hook{
                OnStop: func(_ context.Context) error {
                    cancel()
                    wg.Wait()
                    log.Println("Stop done")
                    return nil
                },
            })

            wg.Add(1)
            go func() {
                defer wg.Done()
                for {
                    select {
                    case <-bg.Done():
                        return
                    case <-time.After(1 * time.Second):
                        log.Println("Working...")
                    }
                }
            }()

            log.Println("Start done")
            return nil
        },
    })

    return &AwesomeService{}
}

func main() {
    fx.New(
        fx.Provide(New),
        fx.Invoke(func(*AwesomeService) {}),
    ).Run()
}

这种方式无需在结构体中存储context、cancel和WaitGroup，既避免了context存储的反模式，也简化了代码结构。

2. 若无需释放资源，是否仍需等待goroutine执行完成？ #

如果后台任务没有持有需要释放的资源（如数据库连接、文件句柄），也没有正在执行的关键业务操作（如提交API请求、写入数据），理论上可以不用等待——应用退出时操作系统会回收进程所有资源，goroutine会被强制终止。

但不建议直接跳过等待：

• 即使当前无资源需要释放，后续业务迭代可能添加相关逻辑，提前保留等待逻辑可避免遗漏。
• 若goroutine正在执行耗时计算或外部请求，直接终止可能导致业务逻辑不完整（如轮询请求发送后未处理响应）。
• 优雅关闭是工程规范中的良好实践，能避免潜在的资源泄漏或数据不一致问题。

如果确定完全无等待必要，可以简化停止逻辑为仅调用cancel()，省略wg.Wait()，但需确保不会产生副作用。

内容的提问来源于stack exchange，提问作者Bullet-tooth