Golang系统信号处理失败怎么办？Golang信号监听实现方案

package main

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

func main() {
    // 创建一个接收信号的channel
    sigChan := make(chan os.Signal, 1)

    // 注册要监听的信号，这里监听SIGINT和SIGTERM
    signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

    // 启动一个goroutine来处理信号
    go func() {
        sig := <-sigChan
        switch sig {
        case syscall.SIGINT:
            fmt.Println("收到SIGINT信号，程序即将退出...")
            // 在这里可以执行一些清理工作
            time.Sleep(2 * time.Second) // 模拟清理操作
            os.Exit(0)
        case syscall.SIGTERM:
            fmt.Println("收到SIGTERM信号，程序即将退出...")
            // 在这里可以执行一些清理工作
            time.Sleep(2 * time.Second) // 模拟清理操作
            os.Exit(0)
        default:
            fmt.Println("收到未知信号:", sig)
        }
    }()

    // 主程序逻辑
    fmt.Println("程序正在运行...")
    for i := 0; i < 10; i++ {
        fmt.Println("运行中...", i)
        time.Sleep(1 * time.Second)
    }

    fmt.Println("程序正常结束")
}

package main

import (
    "fmt"
    "os"
    "os/signal"
    "sync"
    "syscall"
    "time"
)

// WorkerPoolSize 定义 worker pool 的大小
const WorkerPoolSize = 5

// Job 定义 worker 需要处理的任务
type Job struct {
    Signal os.Signal
}

// JobQueue 是一个缓冲 channel，用于存放待处理的任务
var JobQueue chan Job

// Worker 结构体，代表一个 worker
type Worker struct {
    ID int
    JobQueue chan Job
    Quit chan bool
}

// NewWorker 创建一个新的 worker
func NewWorker(id int, jobQueue chan Job) Worker {
    return Worker{
        ID: id,
        JobQueue: jobQueue,
        Quit: make(chan bool),
    }
}

// Start 启动 worker，监听 JobQueue 并处理任务
func (w Worker) Start() {
    go func() {
        for {
            select {
            case job := <-w.JobQueue:
                w.processJob(job)
            case <-w.Quit:
                fmt.Printf("Worker %d stopped\n", w.ID)
                return
            }
        }
    }()
}

// Stop 停止 worker
func (w Worker) Stop() {
    go func() {
        w.Quit <- true
    }()
}

// processJob 处理具体的任务
func (w Worker) processJob(job Job) {
    fmt.Printf("Worker %d processing signal: %v\n", w.ID, job.Signal)
    switch job.Signal {
    case syscall.SIGINT:
        fmt.Println("处理 SIGINT 信号...")
        time.Sleep(2 * time.Second) // 模拟耗时操作
        fmt.Println("SIGINT 处理完成")
    case syscall.SIGTERM:
        fmt.Println("处理 SIGTERM 信号...")
        time.Sleep(2 * time.Second) // 模拟耗时操作
        fmt.Println("SIGTERM 处理完成")
    default:
        fmt.Printf("Worker %d 收到未知信号: %v\n", w.ID, job.Signal)
    }
}

func main() {
    // 创建一个接收信号的 channel
    sigChan := make(chan os.Signal, 1)

    // 注册要监听的信号
    signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

    // 初始化 JobQueue
    JobQueue = make(chan Job, 100)

    // 创建 worker pool
    var workers []Worker
    for i := 0; i < WorkerPoolSize; i++ {
        worker := NewWorker(i+1, JobQueue)
        workers = append(workers, worker)
        worker.Start()
    }

    // 监听信号并将其发送到 JobQueue
    go func() {
        for sig := range sigChan {
            fmt.Printf("接收到信号: %v\n", sig)
            JobQueue <- Job{Signal: sig}
        }
    }()

    // 等待程序结束
    fmt.Println("程序正在运行...")
    time.Sleep(10 * time.Second)

    // 停止所有 worker
    fmt.Println("停止所有 worker...")
    for _, worker := range workers {
        worker.Stop()
    }

    time.Sleep(2 * time.Second)
    fmt.Println("程序退出")
}

package main

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

func main() {
    // 创建一个context
    ctx, cancel := context.WithCancel(context.Background())

    // 创建一个WaitGroup，用于等待所有goroutine完成清理工作
    var wg sync.WaitGroup

    // 启动一个goroutine来执行一些任务
    wg.Add(1)
    go func() {
        defer wg.Done()
        for {
            select {
            case <-ctx.Done():
                fmt.Println("goroutine 收到取消信号，正在执行清理工作...")
                time.Sleep(2 * time.Second) // 模拟清理操作
                fmt.Println("goroutine 清理完成")
                return
            default:
                fmt.Println("goroutine 正在运行...")
                time.Sleep(1 * time.Second)
            }
        }
    }()

    // 监听信号
    sigChan := make(chan os.Signal, 1)
    signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

    // 等待信号
    sig := <-sigChan
    fmt.Printf("接收到信号: %v\n", sig)

    // 取消context
    cancel()

    // 等待所有goroutine完成清理工作
    wg.Wait()

    fmt.Println("程序退出")
}