Apakah mungkin untuk menangkap sinyal Ctrl + C dan menjalankan fungsi pembersihan, dengan cara "menunda"?

Saya ingin menangkap sinyal Ctrl+C( SIGINT) yang dikirim dari konsol dan mencetak beberapa total run parsial.

Apakah ini mungkin di Golang?

Catatan: Ketika saya pertama kali memposting pertanyaan saya bingung tentang Ctrl+Cmenjadi SIGTERMbukan SIGINT.

Anda dapat menggunakan paket os / sinyal untuk menangani sinyal yang masuk. Ctrl+ Cadalah SIGINT , jadi Anda dapat menggunakan ini untuk menjebak 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
    }
}()

Cara Anda menghentikan program dan mencetak informasi sepenuhnya tergantung pada Anda.

Ini bekerja:

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
    }
}

Untuk menambahkan sedikit ke jawaban lain, jika Anda benar-benar ingin menangkap SIGTERM (sinyal default yang dikirim oleh perintah kill), Anda dapat menggunakannya syscall.SIGTERMsebagai ganti os.Interrupt. Berhati-hatilah karena antarmuka syscall khusus untuk sistem dan mungkin tidak berfungsi di mana-mana (mis. Di windows). Tetapi bekerja dengan baik untuk menangkap keduanya:

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

Ada (pada saat posting) satu atau dua kesalahan ketik kecil dalam jawaban yang diterima di atas, jadi inilah versi yang dibersihkan. Dalam contoh ini saya menghentikan profiler CPU ketika menerima 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)                                                     
  }                                                                
}()    

Semua hal di atas tampaknya berfungsi ketika disambung, tetapi halaman sinyal gobyexample memiliki contoh penangkapan sinyal yang benar-benar bersih dan lengkap. Layak ditambahkan ke daftar ini.

Kematian adalah perpustakaan sederhana yang menggunakan saluran dan grup tunggu untuk menunggu sinyal penutupan. Setelah sinyal diterima, maka akan memanggil metode penutupan pada semua struct Anda yang ingin Anda bersihkan.

Anda dapat memiliki goroutine berbeda yang mendeteksi sinyal syscall.SIGINT dan syscall.SIGTERM dan menyampaikannya ke saluran menggunakan sinyal.Notify . Anda dapat mengirim kail ke goroutine itu menggunakan saluran dan menyimpannya dalam irisan fungsi. Ketika sinyal shutdown terdeteksi pada saluran, Anda dapat menjalankan fungsi-fungsi tersebut di slice. Ini dapat digunakan untuk membersihkan sumber daya, menunggu goroutine berjalan untuk menyelesaikan, bertahan data, atau mencetak total menjalankan parsial.

Saya menulis sebuah utilitas kecil dan sederhana untuk menambah dan menjalankan hook saat shutdown. Semoga bisa membantu.

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

Anda dapat melakukan ini dengan cara 'menunda'.

contoh untuk mematikan server dengan anggun:

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

Ini adalah versi lain yang berfungsi jika Anda memiliki beberapa tugas untuk dibersihkan. Kode akan meninggalkan proses pembersihan dalam metode mereka.

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
}

jika Anda perlu membersihkan fungsi utama, Anda perlu menangkap sinyal di utas utama menggunakan go func () juga.

Sekadar catatan jika seseorang membutuhkan cara untuk menangani sinyal di Windows. Saya memiliki persyaratan untuk menangani dari prog A memanggil prog B melalui os / exec tetapi prog B tidak pernah dapat mengakhiri dengan anggun karena mengirim sinyal melalui ex. cmd.Process.Signal (syscall.SIGTERM) atau sinyal lain tidak didukung pada Windows. Cara saya menangani adalah dengan membuat file temp sebagai ex sinyal. .signal.term melalui prog A dan prog B perlu memeriksa apakah file itu ada pada interval dasar, jika ada file itu akan keluar dari program dan menangani pembersihan jika diperlukan, saya yakin ada cara lain tetapi ini berhasil.