监听服务的信号，实现平滑启动，linux信号说明
|
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
38
39
40
41
42
43
44
45
46
47
48
|
package main import ( "context" "fmt" "golang.org/x/sync/errgroup" "net/http" "os" "os/signal" "syscall") func main() { g, ctx := errgroup.WithContext(context.Background()) fmt.Println("服务启动start！") addr := ":9091" s :=&http.Server{ Addr: addr, Handler:http.DefaultServeMux, } g.Go(func() error { http.HandleFunc("/test1", func(writer http.ResponseWriter, request *http.Request) { fmt.Println("tes1") writer.Write([]byte("tes1")) }) return s.ListenAndServe() }) g.Go(func() error { exit := make(chan os.Signal) //监听 Ctrl+C 信号 signal.Notify(exit, syscall.SIGINT, syscall.SIGTERM) select { case <-exit: fmt.Println("进程已被取消~") return s.Shutdown(ctx) } }) err := g.Wait() if err != nil { fmt.Println(err) } fmt.Println("服务启动成功！") if ctx.Err() !=nil { fmt.Println(ctx.Err()) fmt.Println("服务关闭成功！") os.Exit(0) } } |
补充：golang http服务实现平滑重启
看代码吧~
|
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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
|
package main import ( "context" "encoding/json" "fmt" "math/rand" "net/http" "os" "os/signal" "time") var logChan = make(chan map[string]interface{}) var requestStatusMap = map[int]bool{} var done = make(chan bool, 1)var quit = make(chan os.Signal, 1) //为什么这样可以平滑重启？// 正常情况下是server.ListenAndServe() 这个位置hang住整个进程的// 可以把这个程序看成两部分，1个是web服务的监听部分，一个是处理部分， 如果web服务器不开启了，那么就不能处理新进来的请求了（可以理解为一个带路的）// 真正让这个请求断掉 是因为主进程（main）被kill// 所以平滑重启的原理就是，先kill掉web服务器，不让新的请求进来，等现有的全部请求完了，然后结束当前进程func main() { server := newServer() signal.Notify(quit, os.Interrupt) go monitorKill(server, quit) server.ListenAndServe() <-done} func newServer() *http.Server { router := http.NewServeMux() router.HandleFunc("/hello", sayHello) return &http.Server{ Addr: ":8262", Handler: router, }} func monitorKill(server *http.Server, quit <-chan os.Signal) { <-quit go shutDown(server) for { if len(requestStatusMap) != 0 { fmt.Println("目前还有进行中的请求，请稍等") time.Sleep(time.Second * 1) continue } else { close(done) break } }} func shutDown(server *http.Server) { if err := server.Shutdown(context.Background()); err != nil { fmt.Println(err) }} func sayHello(w http.ResponseWriter, r *http.Request) { go WriteInfo()//请求写日志 var uniqueId = GenerateRangeNum(1, 1000) requestStatusMap[uniqueId] = false url := r.URL.Path query := r.URL.RawQuery method := r.Method a := map[string] interface{}{ "url" : url, "method" : method, "query" : query, "response": "hello world!", } logChan<-a w.Write([]byte("hello world!")) time.Sleep(time.Second * 10) delete(requestStatusMap, uniqueId)} func WriteInfo() { info := <-logChan fileName := "/tmp/weekhomework.log" _, err := os.Stat(fileName) if err != nil || os.IsNotExist(err) { _, _ = os.Create(fileName) } f,err := os.OpenFile(fileName, os.O_WRONLY, 0644) defer f.Close() if err !=nil { fmt.Println(err.Error()) } else { //追加写入 为什么O_APPEND 模式无法写入？ todo n, _ := f.Seek(0, 2) infostr, _ := json.Marshal(info) _,err=f.WriteAt([]byte(string(infostr) +"\n"), n) }} func GenerateRangeNum(min int, max int) int { if min == max { return min } rand.Seed(time.Now().Unix()) randNum := rand.Intn(max-min) + min return randNum} |
主要思路：
对于每个请求都做记录，处理完成之后做删除。 用一个协程去监控中断信号，有中断信号先把http服务关闭。
如果这个时候还有请求没有处理完，那么就轮训等待，等全部处理完那么就 发出终止信号结束main进程的执行
以上为个人经验，希望能给大家一个参考，也希望大家多多支持服务器之家。如有错误或未考虑完全的地方，望不吝赐教。
原文链接：https://pangda.blog.csdn.net/article/details/116259908
