Linux Signal及Golang中的信号处理

http://colobu.com/2015/10/09/Linux-Signals/

信号(Signal)是Linux, 类Unix和其它POSIX兼容的操作系统中用来进程间通讯的一种方式。一个信号就是一个异步的通知，发送给某个进程，或者同进程的某个线程，告诉它们某个事件发生了。
当信号发送到某个进程中时，操作系统会中断该进程的正常流程，并进入相应的信号处理函数执行操作，完成后再回到中断的地方继续执行。
如果目标进程先前注册了某个信号的处理程序(signal handler),则此处理程序会被调用，否则缺省的处理程序被调用。

发送信号

kill 系统调用(system call)可以用来发送一个特定的信号给进程。
kill 命令允许用户发送一个特定的信号给进程。
raise 库函数可以发送特定的信号给当前进程。

man kill

The command kill sends the specified signal to the specified process or process group. If no signal is specified, the TERM signal is sent. The TERM signal will kill processes which do not catch this signal. For other processes, it may be necessary to use the KILL (9) signal, since this signal cannot be caught.

Most modern shells have a builtin kill function, with a usage rather similar to that of the command described here. The '-a' and '-p' options, and the possibility to specify pids by command name is a local extension.

If sig is 0, then no signal is sent, but error checking is still performed.

SIGFPESIGSEGVSIGPIPE

• Ctrl-C 发送 INT signal (SIGINT)，通常导致进程结束
• Ctrl-Z 发送 TSTP signal (SIGTSTP); 通常导致进程挂起(suspend)
• Ctrl-\ 发送 QUIT signal (SIGQUIT); 通常导致进程结束 和 dump core.
• Ctrl-T (不是所有的UNIX都支持) 发送INFO signal (SIGINFO); 导致操作系统显示此运行命令的信息

kill -9 pidSIGKILL

处理信号

signal()SIGKILLSIGSTOP

当接收到信号时，进程会根据信号的响应动作执行相应的操作，信号的响应动作有以下几种：

• 中止进程(Term)
• 忽略信号(Ign)
• 中止进程并保存内存信息(Core)
• 停止进程(Stop)
• 继续运行进程(Cont)

signalsigaction

信号类型

man 7 signal

在POSIX.1-1990标准中定义的信号列表

在SUSv2和POSIX.1-2001标准中的信号列表:

Windows中没有SIGUSR1,可以用SIGBREAK或者SIGINT代替。

Go中的Signal发送和处理

SIGTERMos.Signalsignal.Notify

     

      1
     
     

      2
     
     

      3
     
     

      4
     
     

      5
     
     

      6
     
     

      7
     
     

      8
     
     

      9
     
     

      10
     
     

      11
     
     

      12
     
     

      13
     
     

      14
     
     

      15
     
     

      16
     
     

      17
     
     

      18
     
     

      19
     
     

      20
     
     

      21
     
     

      22
     
     

      23
     
     

      24
     
     

      25
     
     

      26
     
     

      27
     
     

      28
     
     

      29
     
     

      30
     
     

      31
     
     

      32
     
     

      33
     
     

      34
     
     

      35
     
     

      36
     
     

      37
     

     

      package main
     
     
     

      import 
      "fmt"
     
     

      import 
      "os"
     
     

      import 
      "os/signal"
     
     

      import 
      "syscall"
     
     
     

      func main() {
     
     
     
    
      // Go signal notification works by sending `os.Signal`
     
     
    
      // values on a channel. We'll create a channel to
     
     
    
      // receive these notifications (we'll also make one to
     
     
    
      // notify us when the program can exit).
     
     

          sigs := 
      make(
      chan os.Signal,
       1)
     
     

          done := 
      make(
      chan 
      bool,
       1)
     
     
     
    
      // `signal.Notify` registers the given channel to
     
     
    
      // receive notifications of the specified signals.
     
     

          signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
     
     
     
    
      // This goroutine executes a blocking receive for
     
     
    
      // signals. When it gets one it'll print it out
     
     
    
      // and then notify the program that it can finish.
     
     
    
      go 
      func() {
     
     

              sig := <-sigs
     
     

              fmt.Println()
     
     

              fmt.Println(sig)
     
     

              done <- 
      true
     
     

          }()
     
     
     
    
      // The program will wait here until it gets the
     
     
    
      // expected signal (as indicated by the goroutine
     
     
    
      // above sending a value on `done`) and then exit.
     
     

          fmt.Println(
      "awaiting signal")
     
     

          <-done
     
     

          fmt.Println(
      "exiting")
     
     

      }
     

go run main.goSIGINT

Go网络服务器如果无缝重启

Go很适合编写服务器端的网络程序。DevOps经常会遇到的一个情况是升级系统或者重新加载配置文件，在这种情况下我们需要重启此网络程序，如果网络程序暂停的时间较长，则给客户的感觉很不好。
如何实现优雅地重启一个Go网络程序呢。主要要解决两个问题：

1. 进程重启不需要关闭监听的端口
2. 既有请求应当完全处理或者超时

@humblehack 在他的文章Graceful Restart in Golang中提供了一种方式，而Florian von Bock根据此思路实现了一个框架endless。
此框架使用起来超级简单:

     

      1
     

     

      err := endless.ListenAndServe(
      "localhost:4242", mux)
     

http.ListenAndServehttp.ListenAndServeTLS

syscall.SIGHUPsyscall.SIGUSR1syscall.SIGUSR2syscall.SIGINTsyscall.SIGTERMsyscall.SIGTSTP

此文章提到的思路是：

exec.Command

     

      1
     
     

      2
     
     

      3
     
     

      4
     
     

      5
     
     

      6
     
     

      7
     
     

      8
     
     

      9
     
     

      10
     
     

      11
     
     

      12
     
     

      13
     
     

      14
     

     

      file := netListener.File() 
      // this returns a Dup()
     
     

      path := 
      "/path/to/executable"
     
     

      args := []
      string{
     
     
    
      "-graceful"}
     
     
     

      cmd := exec.Command(path, args...)
     
     

      cmd.Stdout = os.Stdout
     
     

      cmd.Stderr = os.Stderr
     
     

      cmd.ExtraFiles = []*os.File{file}
     
     
     

      err := cmd.Start()
     
     

      if err != 
      nil {
     
     

          log.Fatalf(
      "gracefulRestart: Failed to launch, error: %v", err)
     
     

      }
     

1. 子进程初始化
   网络程序的启动代码

     

      1
     
     

      2
     
     

      3
     
     

      4
     
     

      5
     
     

      6
     
     

      7
     
     

      8
     
     

      9
     
     

      10
     
     

      11
     
     

      12
     
     

      13
     
     

      14
     
     

      15
     
     

      16
     

     

      server := &http.Server{Addr: 
      "0.0.0.0:8888"}
     
     
     
 
      var gracefulChild 
      bool
     
     
 
      var l net.Listever
     
     
 
      var err error
     
     
     

       flag.BoolVar(&gracefulChild, 
      "graceful", 
      false, 
      "listen on fd open 3 (internal use only)")
     
     
     
 
      if gracefulChild {
     
     

           log.Print(
      "main: Listening to existing file descriptor 3.")
     
     

           f := os.NewFile
      (3, 
      "")
     
     

           l, err = net.FileListener(f)
     
     

       } 
      else {
     
     

           log.Print(
      "main: Listening on a new file descriptor.")
     
     

           l, err = net.Listen(
      "tcp", server.Addr)
     
     

       }
     

1. 父进程停止

     

      1
     
     

      2
     
     

      3
     
     

      4
     
     

      5
     
     

      6
     
     

      7
     

     

      if gracefulChild {
     
     

          parent := syscall.Getppid()
     
     

          log.Printf(
      "main: Killing parent pid: %v", parent)
     
     

          syscall.Kill(parent, syscall.SIGTERM)
     
     

      }
     
     
     

      server.Serve(l)
     

同时他还提供的如何处理已经正在处理的请求。可以查看它的文章了解详细情况。

因此，处理特定的信号可以实现程序无缝的重启。

其它

graceful shutdown实现非常的简单，通过简单的信号处理就可以实现。本文介绍的是graceful restart,要求无缝重启，所以所用的技术相当的hack。

Facebook的工程师也提供了http和net的实现： facebookgo。

参考资料