这是另一个版本，如果你有一些任务要清理。代码将在它们的方法中留下清理过程。

package main

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

)



func main() {

    _,done1:=doSomething1()
    _,done2:=doSomething2()

    //do main thread


    println("wait for finish")
    <-done1
    <-done2
    fmt.Print("clean up done, can exit safely")

}

func doSomething1() (error, chan bool) {
    //do something
    done:=make(chan bool)
    c := make(chan os.Signal, 2)
    signal.Notify(c, os.Interrupt, syscall.SIGTERM)
    go func() {
        <-c
        //cleanup of something1
        done<-true
    }()
    return nil,done
}


func doSomething2() (error, chan bool) {
    //do something
    done:=make(chan bool)
    c := make(chan os.Signal, 2)
    signal.Notify(c, os.Interrupt, syscall.SIGTERM)
    go func() {
        <-c
        //cleanup of something2
        done<-true
    }()
    return nil,done
}

如果你需要清理主函数，你也需要在主线程中使用go func()捕获信号。

Death是一个简单的库，它使用通道和等待组来等待关闭信号。一旦接收到信号，它就会在所有你想要清除的结构上调用close方法。

上面所有的代码拼接起来都可以工作，但是gobyexample的信号页面有一个非常干净完整的信号捕获示例。值得在这个列表中加上。

package main

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

func main() {
    sigs := make(chan os.Signal, 1)
    done := make(chan bool, 1)

    signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)

    go func() {
        sig := <-sigs
        fmt.Println()
        fmt.Println(sig)
        done <- true
    }()

    fmt.Println("awaiting signal")
    <-done
    fmt.Println("exiting")
}

来源:gobyexample.com/signals

只是为了记录如果有人需要一种方法来处理Windows上的信号。

我有一个要求，从程序a通过os/exec调用程序B，但程序B从未能够优雅地终止，因为通过cmd.Process.Signal(sycall . sigterm)或其他信号发送信号在Windows上不支持。

我通过创建一个临时文件作为信号来处理这个问题。例如，程序A创建文件.signal。术语和程序B需要检查该文件是否以间隔为基础存在。如果文件存在，它将退出程序，并在需要时处理清理。

我相信还有其他方法，但这招管用。

这是另一个版本，如果你有一些任务要清理。代码将在它们的方法中留下清理过程。

package main

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

)



func main() {

    _,done1:=doSomething1()
    _,done2:=doSomething2()

    //do main thread


    println("wait for finish")
    <-done1
    <-done2
    fmt.Print("clean up done, can exit safely")

}

func doSomething1() (error, chan bool) {
    //do something
    done:=make(chan bool)
    c := make(chan os.Signal, 2)
    signal.Notify(c, os.Interrupt, syscall.SIGTERM)
    go func() {
        <-c
        //cleanup of something1
        done<-true
    }()
    return nil,done
}


func doSomething2() (error, chan bool) {
    //do something
    done:=make(chan bool)
    c := make(chan os.Signal, 2)
    signal.Notify(c, os.Interrupt, syscall.SIGTERM)
    go func() {
        <-c
        //cleanup of something2
        done<-true
    }()
    return nil,done
}

如果你需要清理主函数，你也需要在主线程中使用go func()捕获信号。

看看这个例子

当我们运行这个程序时，它会阻塞等待一个信号。通过输入Ctrl+C(终端显示为^C)，我们可以发送一个SIGINT信号，导致程序打印中断，然后退出。

信号。Notify注册给定通道以接收指定信号的通知。

package main

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

func main() {

    sig := make(chan os.Signal, 1)
    done := make(chan bool, 1)

    signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)

    go func() {
        sig := <-sig
        fmt.Println()
        fmt.Println(sig)
        done <- true

        fmt.Println("ctrl+c")
    }()

    fmt.Println("awaiting signal")
    <-done
    fmt.Println("exiting")
}

检测HTTP请求取消

package main

import (
    "fmt"
    "net/http"
    "time"
)

func main() {

    mux := http.NewServeMux()
    mux.HandleFunc("/path", func(writer http.ResponseWriter, request *http.Request) {

        time.Sleep(time.Second * 5)

        select {
        case <-time.After(time.Millisecond * 10):

            fmt.Println("started")
            return
        case <-request.Context().Done():
            fmt.Println("canceled")
        }
    })

    http.ListenAndServe(":8000", mux)

}