Signal_(IPC) plays an important role in communication with POSIX system.

For example, what if our code been killed, interrupted, hung on? Generally, the operation system (I am talking about BSD, Unix-like, POSIX system, same in the follow but will omitted), will not really "KILL" it, it will just send a kill signal with id to this process, the this process will process this signal later.

Here is a table to describe the id to default action.

No Name Default Action Description
1 SIGHUP terminate process terminal line hangup
2 SIGINT terminate process interrupt program
3 SIGQUIT create core image quit program
4 SIGILL create core image illegal instruction
5 SIGTRAP create core image trace trap
6 SIGABRT create core image abort program (formerly SIGIOT)
7 SIGEMT create core image emulate instruction executed
8 SIGFPE create core image floating-point exception
9 SIGKILL terminate process kill program
10 SIGBUS create core image bus error
11 SIGSEGV create core image segmentation violation
12 SIGSYS create core image non-existent system call invoked
13 SIGPIPE terminate process write on a pipe with no reader
14 SIGALRM terminate process real-time timer expired
15 SIGTERM terminate process software termination signal
16 SIGURG discard signal urgent condition present on socket
17 SIGSTOP stop process stop (cannot be caught or ignored)
18 SIGTSTP stop process stop signal generated from keyboard
19 SIGCONT discard signal continue after stop
20 SIGCHLD discard signal child status has changed
21 SIGTTIN stop process background read attempted from control terminal
22 SIGTTOU stop process background write attempted to control terminal
23 SIGIO discard signal I/O is possible on a descriptor (see fcntl(2))
24 SIGXCPU terminate process cpu time limit exceeded (see setrlimit(2))
25 SIGXFSZ terminate process file size limit exceeded (see setrlimit(2))
26 SIGVTALRM terminate process virtual time alarm (see setitimer(2))
27 SIGPROF terminate process profiling timer alarm (see setitimer(2))
28 SIGWINCH discard signal Window size change
29 SIGINFO discard signal status request from keyboard
30 SIGUSR1 terminate process User defined signal 1
31 SIGUSR2 terminate process User defined signal 2

You can also find this table using

$ man 3 signal

According to this table, we can easily find the default action of '9' is 'terminate process'

If we execute a command like this

$ kill -9 <process-id>

We are not killed this process, we just send a signal to this process, and this process have suicide later in processing this signal.

However, if we are required to process some important action, and a interrupting action comes, what should we do?

The best way, as far as I am concerned, is roll back if finishing will take some time, or save current status to make sure we could continue it once it restarted.

A lot of code provide this signal proces.

In golang, it provides signal as well, which is implemented using channel.

However, what if we have more than one thing to process in different part? A solution could be like this.

We could create an individual service to replace the default action, and then other code could just register/unregister functions by name (which is used to avoid duplicate processing).

Here is the code of my implementation. Please don't hesitate to give me any feedback if it is possible.

A simple usage could be as follow:

package main

import (

func main() {
    // register a new name
    // this is used to
    name1 := sigr.RegisterOnStopFuncAutoName(func() {
        fmt.Println("Hello, World! #1")
    name2 := sigr.RegisterOnStopFuncAutoName(func() {
        fmt.Println("Hello, World! #2")
    sigr.RegisterOnStopFunc("customized name", func() {
        fmt.Println("Hello, World! #3")
    fmt.Println("name1:", name1, "name2:", name2)
    sigr.RegisterOnStopFunc(name1, func() {
        fmt.Println("Hello, World! #1 #overridden")
    // default: true
    // get verbose log
    // without verbose log, your printing is still work here
    // you may type ctrl+C to excute the functions (name1 and "customized name")
    time.Sleep(time.Duration(20 * time.Second))

The output seems like follow:

$ go run example.go
name1: __auto_1 name2: __auto_2
^C2017/10/26 19:06:17.804737 sigr.go:74: sig: [interrupt] Processing...
2017/10/26 19:06:17.804935 sigr.go:78: Processing task [__auto_1]
Hello, World! #1 #overridden
2017/10/26 19:06:17.804949 sigr.go:78: Processing task [customized name]
Hello, World! #3
2017/10/26 19:06:17.805069 sigr.go:85: sig: [interrupt] Processed, quitting directly
signal: interrupt