Чи можливо знімати сигнал Ctrl + C і запускати функцію очищення "відкладати"?

Я хочу зафіксувати сигнал Ctrl+C( SIGINT), що надсилається з консолі, та роздрукувати деякі часткові підсумки виконання.

Чи можливо це в Голангу?

Примітка. Коли я вперше опублікував це питання, я збентежився Ctrl+C, SIGTERMа не замість цього SIGINT.

Ви можете використовувати пакет 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. Слідкуйте за тим, щоб інтерфейс syscall був специфічним для системи і може працювати не скрізь (наприклад, у Windows). Але це чудово працює, щоб зловити обидва:

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

У прийнятій відповіді вище (в момент публікації) були одні-дві маленькі помилки, тож ось очищена версія. У цьому прикладі я зупиняю процесор CPU при отриманні 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 є дійсно чистий і повний приклад зйомки сигналу. Варто додати до цього списку.

Смерть - це проста бібліотека, яка використовує канали та групу очікування для очікування сигналів відключення. Як тільки сигнал буде отриманий, він зателефонує метод закриття всіх ваших структур, які ви хочете очистити.

У вас може бути інша goroutut, яка виявляє сигнали syscall.SIGINT та syscall.SIGTERM та передає їх на канал за допомогою сигналу. Повідомте . . Ви можете надіслати гачок до цієї програми за допомогою каналу та зберегти його у фрагменті функції. Коли на каналі буде виявлено сигнал відключення, ви можете виконати ці функції в зрізі. Це можна використовувати для очищення ресурсів, очікування закінчення роботи програм, збереження даних або друку часткових підсумків запуску.

Я написав невелику і просту утиліту для додавання та запуску гачків при відключенні. Сподіваюся, це може бути корисною.

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 ().

Просто для запису, якщо комусь потрібен спосіб обробляти сигнали в Windows. У мене була вимога обробляти програму прог. Виклику прогу B через os / exec, але прога B ніколи не змогла граціозно припинитися, тому що передача сигналів через ex. cmd.Process.Signal (syscall.SIGTERM) або інші сигнали не підтримуються у Windows. Я працював шляхом створення тимчасового файлу як сигналу, наприклад. .signal.term через prog A та prog B потрібно перевірити, чи існує цей файл на інтервальній базі, якщо файл існує, він вийде з програми та обробить очищення, якщо потрібно, я впевнений, що є інші способи, але це зробило роботу.