Можно ли захватить сигнал Ctrl + C и запустить функцию очистки в отложенном режиме?

Вы можете использовать пакет os / signal для обработки входящих сигналов. Ctrl + C - это SIGINT, так что вы можете использовать это, чтобы поймать os.Interrupt.

c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
go func(){
    for sig := range c {
        // sig is a ^C, handle it
    }
}()

Способ, которым вы завершаете свою программу и распечатываете информацию, полностью зависит от вас.

Это работает:

package main

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

func cleanup() {
    fmt.Println("cleanup")
}

func main() {
    c := make(chan os.Signal)
    signal.Notify(c, os.Interrupt, syscall.SIGTERM)
    go func() {
        <-c
        cleanup()
        os.Exit(1)
    }()

    for {
        fmt.Println("sleeping...")
        time.Sleep(10 * time.Second) // or runtime.Gosched() or similar per @misterbee
    }
}

Чтобы немного добавить к другим ответам, если вы действительно хотите поймать SIGTERM (сигнал по умолчанию, отправляемый командой kill), вы можете использовать syscall.SIGTERM вместо os.Interrupt. Помните, что интерфейс системных вызовов зависит от системы и может работать не везде (например, в Windows). Но он отлично работает, чтобы поймать и то, и другое:

c := make(chan os.Signal, 2)
signal.Notify(c, os.Interrupt, syscall.SIGTERM)
....

В принятом выше ответе были (на момент публикации) одна или две небольших опечатки, так что вот исправленная версия. В этом примере я останавливаю профилировщик ЦП при получении Ctrl + C.

// capture ctrl+c and stop CPU profiler                            
c := make(chan os.Signal, 1)                                       
signal.Notify(c, os.Interrupt)                                     
go func() {                                                        
  for sig := range c {                                             
    log.Printf("captured %v, stopping profiler and exiting..", sig)
    pprof.StopCPUProfile()                                         
    os.Exit(1)                                                     
  }                                                                
}()    

Кажется, что все вышеперечисленное работает при соединении, но на странице сигналов 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

посмотрите пример

Когда мы запустим эту программу, она заблокируется в ожидании сигнала. Набрав 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)

}

У вас может быть другая горутина, которая обнаруживает сигналы syscall.SIGINT и syscall.SIGTERM и передает их на канал с помощью signal.Notify. Вы можете послать ловушку к этой горутине, используя канал, и сохранить его в функциональном срезе. Когда на канале обнаружен сигнал выключения, вы можете выполнять эти функции в слайсе. Это можно использовать для очистки ресурсов, ожидания завершения выполнения горутин, сохранения данных или печати итоговых результатов частичного выполнения.

Я написал небольшую и простую утилиту для добавления и запуска хуков при завершении работы. Надеюсь, это поможет.

https://github.com/ankit-arora/go-utils/blob/master/go-shutdown-hook/shutdown-hook.go.

Вы можете сделать это «отложить».

пример для корректного завершения работы сервера:

srv := &http.Server{}

go_shutdown_hook.ADD(func() {
    log.Println("shutting down server")
    srv.Shutdown(nil)
    log.Println("shutting down server-done")
})

l, err := net.Listen("tcp", ":3090")

log.Println(srv.Serve(l))

go_shutdown_hook.Wait()

Это еще одна версия, которая работает, если у вас есть какие-то задачи по очистке. Код оставит процесс очистки в своем методе.

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 для всех ваших структур, которые вы хотите очистить.

Просто для протокола, если кому-то нужен способ обработки сигналов в Windows.

У меня было требование обрабатывать из программы A, вызывающей программу B через os / exec, но программа B никогда не могла корректно завершиться, потому что отправка сигналов через cmd.Process.Signal(syscall.SIGTERM) или другие сигналы не поддерживаются в Windows.

Я решил эту проблему, создав временный файл в качестве сигнала. Например, программа A создает файл .signal.term, а программе B необходимо проверять, существует ли этот файл на основе интервалов. Если файл существует, он выйдет из программы и при необходимости выполнит очистку.

Я уверен, что есть другие способы, но это сработало.