暴力的重啟服務方案
一般服務器重啟可以直接通過 kill 命令殺死進程，然后重新啟動一個新的進程即可。但這種方法比較粗暴，有可能導致某些正在處理中的客戶端請求失敗，如果請求正在寫數據，那么還有可能導致數據丟失或者數據不一致等。
那么有什么方式可以優雅的重啟服務呢？
優雅的重啟服務方案
優雅的重啟方式流程如下：
從上面的流程可以看出，舊進程必須等待所有的請求連接完成后才會退出，請求不會被強制關閉，所以是個優雅的重啟方式。
使用Go實現優雅重啟
下面我們使用Go語言來演示怎么實現優雅啟動功能，我們先來看看原理圖：
從原理圖可以知道，重啟時首先通過發送 SIGHUP信號 給服務進程，服務進程收到 SIGHUP信號 后會 fork 一個新進程來處理新的請求，然后新進程會發送 SIGTERM信號 給舊服務進程（父進程），舊服務進程接收到 SIGTERM信號 后會關閉監聽的 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：監聽客戶端請求的 Listener
- wg：用于記錄還有多少客戶端請求沒有完成
- sigChan：用于接收信號的管道
- isChild：用于重啟時標志本進程是否是為一個新進程
- state：當前進程的狀態
- lock：用于鎖定一些資源
定義一個創建 endlessServer 結構的函數：
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() 函數的實現比較簡單，就是創建一個 endlessServer 結構，然后初始化其各個成員。要注意的是，是否為新進程是通過讀取環境變量 ENDLESS_CONTINUE 來判斷的，如果定義了 ENDLESS_CONTINUE 環境變量，就是說當前進程是新的服務進程。
用過Go語言的HTTP包的同學應該知道，要進行監聽客戶端請求的話必須調用其 ListenAndServe() 函數，所以我們要定義這個函數：
func ListenAndServe(addr string, handler http.Handler) error {
server := NewServer(addr, handler)
return server.ListenAndServe()
}
函數的實現很簡單，就是先調用 NewServer() 函數創建一個 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() 方法首先會創建一個協程處理 handleSignals() 方法，這個方法主要是處理信號，下面會介紹。然后調用 getListener() 方法獲取一個類型為 net.Listener 的對象，然后調用 newEndlessListener() 函數創建一個類型為 endlessListener 的對象。再通過判斷當前進程是否為新的處理進程，如果是就調用 syscall.Kill() 方法發送一個 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() 方法主要監聽3種信號， syscall.SIGHUP 、 syscall.SIGINT 和 syscall.SIGTERM 。 syscall.SIGHUP 信號為重啟信號，而 syscall.SIGINT 信號為關閉服務信號，而 syscall.SIGTERM 信號主要是新的服務進程發送給舊的服務進程，告訴其關閉監聽處理客戶端的socket。當收到 syscall.SIGHUP 信號時，需要調用 fork() 方法來創建一個新的服務進程，而收到 syscall.SIGINT 和 syscall.SIGTERM 信號主要調用 shutdown() 方法來關閉當前進程。
再來看看創建新服務進程的 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() 方法來創建一個 Cmd 對象，然后調用其 Start() 方法來啟動一個新進。要注意的是，創建新進程前需要設置環境變量 ENDLESS_CONTINUE ，這是告訴新進程需要發送 syscall.SIGTERM 信號給父進程。還有就是通過 Cmd 對象的 ExtraFiles 成員把監聽客戶端連接的socket句柄傳遞給新服務處理進程了。
再來看看關閉服務進程的 shutdown() 方法：
func (srv *endlessServer) shutdown() {
err := srv.EndlessListener.Close()
}
這個方法很簡單，就是調用 net.Listener 對象的 Close() 方法來關閉監聽客戶端請求的socket。關閉監聽客戶端請求的socket后，主循環會退出處理，然后會退出進程。
接著我們來看看接收客戶端請求的 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
}
主要要注意的是，函數最后會調用 el.server.wg.Add(1) 這行代碼來增加客戶端請求的計數器，這是優雅重啟的關鍵。因為在 endlessServer.Serve() 方法中會等待所有客戶端請求處理完畢才會退出，我們來看看 endlessServer.Serve() 方法的實現：
func (srv *endlessServer) Serve() (err error) {
err = srv.Server.Serve(srv.EndlessListener)
srv.wg.Wait()
return
}
可以看到， endlessServer.Serve() 方法最后會調用 srv.wg.Wait() 這行代碼來等待所有客戶端請求完成。那么客戶端連接計數器什么時候會減少呢？在 endlessConn.Close() 方法中可以看到計數器減少的操作：
func (w endlessConn) Close() error {
err := w.Conn.Close()
if err == nil {
w.server.wg.Done()
}
return err
}
可以看到， endlessConn.Close() 方法最后會調用 w.server.wg.Done() 這 行代碼來減少客戶端請求計數器。 至此，優雅重啟服務的實現就完成。
當然，本篇文章主要介紹的是優雅重啟的原理，完成的源碼實現還是要查看 endless 這個庫。
總結
以上所述是小編給大家介紹的使用Go實現優雅重啟服務功能，希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回復大家的。在此也非常感謝大家對腳本之家網站的支持！
如果你覺得本文對你有幫助，歡迎轉載，煩請注明出處，謝謝！
您可能感興趣的文章:- 解決django服務器重啟端口被占用的問題
- 詳解如何熱重啟golang服務器
- 在Go程序中實現服務器重啟的方法
