暴力的重啟服務方案

一般服務器重啟可以直接通過 kill 命令殺死進程，然后重新啟動一個新的進程即可。但這種方法比較粗暴，有可能導致某些正在處理中的客戶端請求失敗，如果請求正在寫數(shù)據(jù)，那么還有可能導致數(shù)據(jù)丟失或者數(shù)據(jù)不一致等。

那么有什么方式可以優(yōu)雅的重啟服務呢？

優(yōu)雅的重啟服務方案

優(yōu)雅的重啟方式流程如下：

從上面的流程可以看出，舊進程必須等待所有的請求連接完成后才會退出，請求不會被強制關閉，所以是個優(yōu)雅的重啟方式。

使用Go實現(xiàn)優(yōu)雅重啟

下面我們使用Go語言來演示怎么實現(xiàn)優(yōu)雅啟動功能，我們先來看看原理圖：

從原理圖可以知道，重啟時首先通過發(fā)送 SIGHUP信號 給服務進程，服務進程收到  SIGHUP信號 后會  fork 一個新進程來處理新的請求，然后新進程會發(fā)送  SIGTERM信號 給舊服務進程（父進程），舊服務進程接收到  SIGTERM信號 后會關閉監(jiān)聽的  socket句柄 （停止接收新請求），并且等待未處理完成的請求完成后再退出進程。

下面通過代碼來說明這個流程，代碼主要參考 endless 這個庫，有興趣可以查看其源碼。

首先我們定義一個名為 endlessServer 的結構并且繼承  http.Server 結構：

type endlessServer struct {
  http.Server
  EndlessListener net.Listener
  wg        sync.WaitGroup
  sigChan     chan os.Signal
  isChild     bool
  state      uint8
  lock       *sync.RWMutex
}

Go的繼承很簡單，就是在定義結構時把要繼承的結構嵌入到里面就可以了。

這里說明一下 endlessServer 各個成員的作用吧：

• Server：用于繼承 http.Server 結構
• EndlessListener：監(jiān)聽客戶端請求的 Listener
• wg：用于記錄還有多少客戶端請求沒有完成
• sigChan：用于接收信號的管道
• isChild：用于重啟時標志本進程是否是為一個新進程
• state：當前進程的狀態(tài)
• lock：用于鎖定一些資源

定義一個創(chuàng)建 endlessServer 結構的函數(shù)：

func NewServer(addr string, handler http.Handler) (srv *endlessServer) {
  isChild := os.Getenv("ENDLESS_CONTINUE") != ""
  srv = endlessServer{
    wg:   sync.WaitGroup{},
    sigChan: make(chan os.Signal),
    isChild: isChild,
    state: STATE_INIT,
    lock: sync.RWMutex{},
  }
  srv.Server.Addr = addr
  srv.Server.ReadTimeout = 0
  srv.Server.WriteTimeout = 0
  srv.Server.MaxHeaderBytes = 0
  srv.Server.Handler = handler
  return
}

NewServer() 函數(shù)的實現(xiàn)比較簡單，就是創(chuàng)建一個  endlessServer 結構，然后初始化其各個成員。要注意的是，是否為新進程是通過讀取環(huán)境變量  ENDLESS_CONTINUE 來判斷的，如果定義了  ENDLESS_CONTINUE 環(huán)境變量，就是說當前進程是新的服務進程。

用過Go語言的HTTP包的同學應該知道，要進行監(jiān)聽客戶端請求的話必須調用其 ListenAndServe() 函數(shù)，所以我們要定義這個函數(shù)：

func ListenAndServe(addr string, handler http.Handler) error {
  server := NewServer(addr, handler)
  return server.ListenAndServe()
}

函數(shù)的實現(xiàn)很簡單，就是先調用 NewServer() 函數(shù)創(chuàng)建一個  endlessServer 結構，然后調用其  ListenAndServe() 方法。所以我們要為  endlessServer 結構定義一個  ListenAndServe() 方法：

func (srv *endlessServer) ListenAndServe() (err error) {
  addr := srv.Addr
  if addr == "" {
    addr = ":http"
  }
  go srv.handleSignals()
  l, err := srv.getListener(addr)
  if err != nil {
    log.Println(err)
    return
  }
  srv.EndlessListener = newEndlessListener(l, srv)
  if srv.isChild {
    syscall.Kill(syscall.Getppid(), syscall.SIGTERM)
  }
  return srv.Serve()
}

ListenAndServe() 方法首先會創(chuàng)建一個協(xié)程處理  handleSignals() 方法，這個方法主要是處理信號，下面會介紹。然后調用  getListener() 方法獲取一個類型為  net.Listener 的對象，然后調用  newEndlessListener() 函數(shù)創(chuàng)建一個類型為  endlessListener 的對象。再通過判斷當前進程是否為新的處理進程，如果是就調用  syscall.Kill() 方法發(fā)送一個  SIGTERM信號 給父進程（舊的服務處理進程），最后調用  Serve() 方法開始處理客戶端連接。

我們先來看看處理信號的 handleSignal() 方法：

func (srv *endlessServer) handleSignals() {
  var sig os.Signal
  signal.Notify(
    srv.sigChan,
    syscall.SIGHUP,
    syscall.SIGINT,
    syscall.SIGTERM,
  )
  pid := syscall.Getpid()
  for {
    sig = -srv.sigChan
    srv.signalHooks(PRE_SIGNAL, sig)
    switch sig {
    case syscall.SIGHUP:
      err := srv.fork()
      if err != nil {
        log.Println("Fork err:", err)
      }
    case syscall.SIGINT:
      srv.shutdown()
    case syscall.SIGTERM:
      srv.shutdown()
    default:
      log.Printf("Received %v: nothing i care about...\n", sig)
    }
  }
}

handleSignal() 方法主要監(jiān)聽3種信號， syscall.SIGHUP 、 syscall.SIGINT 和  syscall.SIGTERM 。 syscall.SIGHUP 信號為重啟信號，而  syscall.SIGINT 信號為關閉服務信號，而  syscall.SIGTERM 信號主要是新的服務進程發(fā)送給舊的服務進程，告訴其關閉監(jiān)聽處理客戶端的socket。當收到  syscall.SIGHUP 信號時，需要調用  fork() 方法來創(chuàng)建一個新的服務進程，而收到  syscall.SIGINT 和  syscall.SIGTERM 信號主要調用  shutdown() 方法來關閉當前進程。

再來看看創(chuàng)建新服務進程的 fork() 方法：

func (srv *endlessServer) fork() (err error) {
  files := []*os.File{
    srv.EndlessListener.(*endlessListener).File(),
  }
  env := append(
    os.Environ(),
    "ENDLESS_CONTINUE=1",
  )
  path := os.Args[0]
  var args []string
  if len(os.Args) > 1 {
    args = os.Args[1:]
  }
  cmd := exec.Command(path, args...)
  cmd.Stdout = os.Stdout
  cmd.Stderr = os.Stderr
  cmd.ExtraFiles = files
  cmd.Env = env
  err = cmd.Start()
  if err != nil {
    log.Fatalf("Restart: Failed to launch, error: %v", err)
  }
  return
}

fork() 方法也比較簡單，主要是使用  exec 包的  Command() 方法來創(chuàng)建一個  Cmd 對象，然后調用其  Start() 方法來啟動一個新進。要注意的是，創(chuàng)建新進程前需要設置環(huán)境變量  ENDLESS_CONTINUE ，這是告訴新進程需要發(fā)送  syscall.SIGTERM 信號給父進程。還有就是通過  Cmd 對象的  ExtraFiles 成員把監(jiān)聽客戶端連接的socket句柄傳遞給新服務處理進程了。

再來看看關閉服務進程的 shutdown() 方法：

func (srv *endlessServer) shutdown() {
  err := srv.EndlessListener.Close()
}

這個方法很簡單，就是調用 net.Listener 對象的  Close() 方法來關閉監(jiān)聽客戶端請求的socket。關閉監(jiān)聽客戶端請求的socket后，主循環(huán)會退出處理，然后會退出進程。

接著我們來看看接收客戶端請求的 endlessListener.Accept() 方法：

func (el *endlessListener) Accept() (c net.Conn, err error) {
  tc, err := el.Listener.(*net.TCPListener).AcceptTCP()
  if err != nil {
    return
  }
  tc.SetKeepAlive(true)         // see http.tcpKeepAliveListener
  tc.SetKeepAlivePeriod(3 * time.Minute) // see http.tcpKeepAliveListener
  c = endlessConn{
    Conn:  tc,
    server: el.server,
  }
  el.server.wg.Add(1)
  return
}

主要要注意的是，函數(shù)最后會調用 el.server.wg.Add(1) 這行代碼來增加客戶端請求的計數(shù)器，這是優(yōu)雅重啟的關鍵。因為在  endlessServer.Serve() 方法中會等待所有客戶端請求處理完畢才會退出，我們來看看  endlessServer.Serve() 方法的實現(xiàn)：

func (srv *endlessServer) Serve() (err error) {
  err = srv.Server.Serve(srv.EndlessListener)
  srv.wg.Wait()
  return
}

可以看到， endlessServer.Serve() 方法最后會調用  srv.wg.Wait() 這行代碼來等待所有客戶端請求完成。那么客戶端連接計數(shù)器什么時候會減少呢？在  endlessConn.Close() 方法中可以看到計數(shù)器減少的操作：

func (w endlessConn) Close() error {
  err := w.Conn.Close()
  if err == nil {
    w.server.wg.Done()
  }
  return err
}

可以看到， endlessConn.Close() 方法最后會調用  w.server.wg.Done() 這 行代碼來減少客戶端請求計數(shù)器。 至此，優(yōu)雅重啟服務的實現(xiàn)就完成。

當然，本篇文章主要介紹的是優(yōu)雅重啟的原理，完成的源碼實現(xiàn)還是要查看 endless 這個庫。

總結

以上所述是小編給大家介紹的使用Go實現(xiàn)優(yōu)雅重啟服務功能，希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回復大家的。在此也非常感謝大家對腳本之家網(wǎng)站的支持！
如果你覺得本文對你有幫助，歡迎轉載，煩請注明出處，謝謝！