Golang优雅管理应用关闭信号的插件库Death使用指南

Death是一个轻量级的Go库，用于优雅地管理应用程序的关闭信号。它可以帮助你在程序收到终止信号时，优雅地关闭所有goroutine和资源。

安装Death库

go get github.com/vrecan/death/v3

基本使用示例

package main

import (
	"context"
	"fmt"
	"time"
	
	"github.com/vrecan/death/v3"
)

func main() {
	// 创建Death实例
	d := death.NewDeath()
	
	// 模拟一个需要优雅关闭的服务
	go func() {
		for {
			select {
			case <-d.Dying():
				fmt.Println("服务正在关闭...")
				return
			default:
				fmt.Println("服务运行中...")
				time.Sleep(1 * time.Second)
			}
		}
	}()
	
	// 等待系统信号并优雅关闭
	d.WaitForDeath()
	fmt.Println("应用程序已优雅关闭")
}

高级功能

1. 自定义关闭信号

func main() {
	d := death.NewDeath(
		death.Signals(syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT),
	)
	
	go func() {
		<-d.Dying()
		fmt.Println("收到关闭信号，开始清理...")
		// 执行清理操作
	}()
	
	d.WaitForDeath()
}

2. 注册关闭回调函数

func main() {
	d := death.NewDeath()
	
	// 注册关闭时的回调函数
	d.RegisterBeforeDeath(func() {
		fmt.Println("执行关闭前的清理工作")
		time.Sleep(2 * time.Second) // 模拟清理耗时
	})
	
	go func() {
		for {
			select {
			case <-d.Dying():
				fmt.Println("服务正在关闭...")
				return
			default:
				fmt.Println("服务运行中...")
				time.Sleep(1 * time.Second)
			}
		}
	}()
	
	d.WaitForDeath()
}

3. 结合context使用

func main() {
	d := death.NewDeath()
	ctx := context.Background()
	
	// 创建一个可以感知Death的context
	ctx, cancel := context.WithCancel(ctx)
	defer cancel()
	
	go func() {
		<-d.Dying()
		fmt.Println("收到关闭信号，取消context")
		cancel()
	}()
	
	go func() {
		for {
			select {
			case <-ctx.Done():
				fmt.Println("context被取消，停止服务")
				return
			default:
				fmt.Println("服务运行中...")
				time.Sleep(1 * time.Second)
			}
		}
	}()
	
	d.WaitForDeath()
}

实际应用示例

package main

import (
	"fmt"
	"net/http"
	"sync"
	"time"
	
	"github.com/vrecan/death/v3"
)

type Server struct {
	httpServer *http.Server
	wg         sync.WaitGroup
}

func NewServer() *Server {
	mux := http.NewServeMux()
	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("Hello, World!"))
	})
	
	return &Server{
		httpServer: &http.Server{
			Addr:    ":8080",
			Handler: mux,
		},
	}
}

func (s *Server) Start() {
	s.wg.Add(1)
	go func() {
		defer s.wg.Done()
		fmt.Println("HTTP服务器启动")
		if err := s.httpServer.ListenAndServe(); err != http.ErrServerClosed {
			fmt.Printf("HTTP服务器错误: %v\n", err)
		}
	}()
}

func (s *Server) Stop() error {
	fmt.Println("停止HTTP服务器...")
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	return s.httpServer.Shutdown(ctx)
}

func main() {
	server := NewServer()
	server.Start()
	
	d := death.NewDeath()
	
	// 注册关闭时的回调
	d.RegisterBeforeDeath(func() {
		fmt.Println("开始优雅关闭...")
		if err := server.Stop(); err != nil {
			fmt.Printf("关闭服务器时出错: %v\n", err)
		}
		server.wg.Wait() // 等待所有goroutine完成
	})
	
	fmt.Println("应用程序运行中，按Ctrl+C停止...")
	d.WaitForDeath()
	fmt.Println("应用程序已完全关闭")
}

最佳实践

1. 资源清理：确保所有打开的文件、数据库连接、网络连接等在关闭时都被正确释放

2. 超时控制：为关闭操作设置合理的超时时间，避免无限等待

3. 并发安全：确保关闭操作是并发安全的

4. 日志记录：记录关闭过程中的关键步骤，便于问题排查

5. 分级关闭：按照依赖关系有序关闭服务，例如先关闭接收新请求，再处理已有请求，最后关闭资源

Death库提供了一种简单而强大的方式来管理Go应用程序的生命周期，特别是在需要优雅关闭的场景下非常有用。