Golang中处理操作系统信号时如何与错误处理机制结合

SIGTERM

SIGINT

context

os/signal

context

context.CancelFunc

context

SIGTERM

SIGINT

SIGTERM

error

context

context

context.CancelFunc

context

context

Done()

package main

import (
    "context"
    "fmt"
    "log"
    "os"
    "os/signal"
    "syscall"
    "time"
)

func main() {
    // 创建一个带有取消功能的context
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel() // 确保在main函数退出时调用cancel，释放资源

    // 创建一个通道来接收操作系统信号
    sigChan := make(chan os.Signal, 1)
    // 监听SIGINT和SIGTERM信号
    signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

    // 启动一个goroutine来监听信号并取消context
    go func() {
        sig := <-sigChan
        log.Printf("收到信号: %v, 正在尝试优雅关闭...", sig)
        cancel() // 收到信号后，取消context
    }()

    // 模拟一些工作goroutine
    for i := 0; i < 3; i++ {
        go worker(ctx, i)
    }

    // 主goroutine等待context被取消
    select {
    case <-ctx.Done():
        log.Println("主程序收到取消信号，开始清理...")
        // 这里可以进行一些主程序的清理工作
        // 比如等待所有worker完成
        // 为了演示，我们简单地等待几秒
        time.Sleep(2 * time.Second)
        log.Println("主程序清理完成，退出。")
    }
}

func worker(ctx context.Context, id int) {
    log.Printf("Worker %d 启动", id)
    for {
        select {
        case <-ctx.Done():
            log.Printf("Worker %d 收到取消信号，开始清理...", id)
            // 模拟worker的清理工作，可能涉及IO操作或资源释放
            time.Sleep(time.Duration(id+1) * time.Second) // 模拟不同worker清理时间
            log.Printf("Worker %d 清理完成。", id)
            return
        case <-time.After(1 * time.Second):
            // 模拟worker正在做一些周期性任务
            log.Printf("Worker %d 正在工作...", id)
        }
    }
}

SIGINT

SIGTERM

sigChan

cancel()

ctx.Done()

worker

select

ctx.Done()

signal.Notify

sigChan

sigChan

sigChan

Shutdown

Stop()

error

type Stoppable interface {
    Stop(ctx context.Context) error
    Name() string
}

// 模拟一个数据库连接
type DBConnection struct {
    name string
}

func (db *DBConnection) Stop(ctx context.Context) error {
    log.Printf("%s: 正在关闭数据库连接...", db.name)
    // 模拟关闭操作可能失败
    if time.Now().Unix()%2 == 0 { // 随机模拟失败
        return fmt.Errorf("%s: 关闭数据库连接失败: 网络中断", db.name)
    }
    time.Sleep(500 * time.Millisecond)
    log.Printf("%s: 数据库连接已关闭。", db.name)
    return nil
}

func (db *DBConnection) Name() string {
    return db.name
}

// 模拟一个HTTP服务器
type HTTPServer struct {
    name string
}

func (s *HTTPServer) Stop(ctx context.Context) error {
    log.Printf("%s: 正在关闭HTTP服务器...", s.name)
    // 模拟服务器关闭操作
    time.Sleep(300 * time.Millisecond)
    log.Printf("%s: HTTP服务器已关闭。", s.name)
    return nil
}

func (s *HTTPServer) Name() string {
    return s := s.name
}

func main() {
    // ... (信号和context处理部分同上) ...

    // 假设我们有一些需要停止的组件
    components := []Stoppable{
        &DBConnection{name: "MainDB"},
        &HTTPServer{name: "APIServer"},
        &DBConnection{name: "CacheDB"}, // 另一个数据库，可能也会失败
    }

    select {
    case <-ctx.Done():
        log.Println("主程序收到取消信号，开始清理所有组件...")
        var cleanupErrors []error
        for _, comp := range components {
            // 在清理时也传入context，允许清理操作在超时后中断
            cleanupCtx, cancelCleanup := context.WithTimeout(context.Background(), 5*time.Second)
            defer cancelCleanup()

            if err := comp.Stop(cleanupCtx); err != nil {
                cleanupErrors = append(cleanupErrors, fmt.Errorf("组件 %s 清理失败: %w", comp.Name(), err))
            }
        }

        if len(cleanupErrors) > 0 {
            log.Println("清理过程中发现以下错误:")
            for _, err := range cleanupErrors {
                log.Printf(" - %v", err)
            }
            os.Exit(1) // 如果清理失败，以非零状态码退出
        } else {
            log.Println("所有组件清理完成，程序正常退出。")
            os.Exit(0)
        }
    }
}

cleanupErrors

os.Exit(1)