阅读 1020

原来服务端的退出姿势也可以这么优雅

小知识,大挑战!本文正在参与“程序员必备小知识”创作活动

本文已参与 「掘力星计划」 ,赢取创作大礼包,挑战创作激励金。

相信写过 golang 的 xdm 都写过 http 服务器吧,用 golang 写服务器是不是很爽呀

最简单的 http 服务端

咱们来写一个简单的 http 服务器

func main() {
	srvMux := http.NewServeMux()
	srvMux.HandleFunc("/getinfo", getinfo)
	http.ListenAndServe(":9090", srvMux)

}

func getinfo(w http.ResponseWriter, r *http.Request) {
	fmt.Println("i am xiaomotong!!!")
	w.Write([]byte("you are access right!!\n"))
}
复制代码

这个功能非常简单,就是监听了本地的 9090 端口,并且其中有一个 url 是会处理请求的,/getinfo ,咱们可以通过如下指令来请求一下看看效果

# curl localhost:9090/getinfo
you are access right!!
复制代码

明确是可以正常访问的,且也会拿到我们对应的信息,服务器的日志也是正常的

咱们思考一下,这个时候如果遇到了意外,程序崩溃了,panic 了,或者我们认为的 kill 掉了,我们如何判断服务端是如何退出的呢?

加入 信号的 服务端

我们写 C/C++ 的时候对于信号应该不陌生吧,在 golang 里面,我们也加入信号来识别是否是认为 kill 程序的

linux 里面可以通过 man kill 查看 kill 指令的详细说明

这里我们可以看到一个kill -9 是对应的 SIGKILL 信号 ,我们还知道 SIGINT 信号是 Ctrl-C 的时候会发出这个信号,也是一个中断信号,如果对于这点不清楚话,可以网络上搜索一下 linux 信号列表

func main() {
	sig := make(chan os.Signal)
	signal.Notify(sig, syscall.SIGINT, syscall.SIGKILL)

	srvMux := http.NewServeMux()
	srvMux.HandleFunc("/getinfo", getinfo)
	go http.ListenAndServe(":9090", srvMux)

	 fmt.Println(<-sig)
}
复制代码

http.ListenAndServe 是阻塞的,则此处咱们监听 9090 的服务是开了一个单独处理

验证一下

# go run main.go
^Cinterrupt
复制代码

这个时候,我们的 http 服务器,已经能够区分信号了,知道自己是如何退出的了

咱们的需求有慢慢的增加,实际工作中,肯定不能做的这么 cuo

优雅的退出

工作中,我们带有 http 的服务端,肯定还有别的处理逻辑,例如读写文件,GRPC 通信,或者是使用数据库,那么我们程序关闭情况,还是要根据情况来处理,要遵循原子性

有如下 2 种情况:

  • 对于数据没有严格的质量要求,程序 panic 也无所谓,那么这个时候不用优雅关闭也没有啥问题
  • 对于上述说到的会操作数据库,读写文件等等会修改数据的,这里可不期望操作数据的过程中被中断,我们要遵循原子性,咱们的程序需要提供一个缓冲的时间,来优雅的退出

正常工作中退出必须是优雅的

如何实现优雅退出呢?

例如上面的例子,当主协程收到了中断信号后,就会马上退出程序,子协程也会相应退出

如果需要主协程等待子协程处理完当前手里的活再退出,那么我们是不是需要让主协程和子协程相互通信,才有可能实现呢?

使用 2 个 channel 来实现优雅关闭

这个方法比较容易想到

实现大体分为 2 步走:

  • 主协程收到中断信号后,通知子协程优雅关闭 ,这里命名为 stopCh
  • 子协程收到通知后,处理完手头的通知主协程关闭程序,这里命名为 closeCh
func main() {
	sig := make(chan os.Signal)
	signal.Notify(sig, syscall.SIGINT, syscall.SIGKILL)

	stopCh := make(chan int)
	closeCh := make(chan int)

	srvMux := http.NewServeMux()
	srvMux.HandleFunc("/getinfo", getinfo)
	go http.ListenAndServe(":19999", srvMux)

	go func(stopCh, closeCh chan int) {
		for {
			select {
			case <-stopCh:
				fmt.Println(" processing tasks")
                // 模拟正在处理数据
				time.Sleep(time.Second*time.Duration(2))
				fmt.Println("process over ")
				closeCh <- 1
			}
		}
	}(stopCh, closeCh)

	<-sig
	stopCh <- 1
	<-closeCh
	fmt.Println("close server ")
}
复制代码

此处我们可以看出使用了 2 个通道来让主协程和子协程相互通信

开辟一个协程,执行匿名函数来监听 stopCh 通道是否有数据,若有数据,说明主协程收到了信号,并且通知子协程要优雅关闭了

这个时候,子协程做完自己的事情,就在 closeCh 写入数据,通知主协程可以正常关闭程序了

使用嵌套的 channel 来实现

使用 嵌套的 channel 来实现优雅关闭,可能一下子还想不到,不过官网有给我们一些方向

实现思路是:

  • 使用一个通道 stopCh,通道 stopCh 里面的元素是另外一个通道 tmpCh
  • 当主协程收到退出信号时,在 stopCh 中写入数据 tmpCh,并开始监听 tmpCh 是否有数据
  • 子协程从 stopCh 读取到数据 tmpCh 时,便知道自己需要优雅关闭了,处理完自己的事情之后,子协程往 tmpCh 写入数据
  • 主协程监听到 tmpCh 有数据,则退出程序
func main() {
	sig := make(chan os.Signal)
	signal.Notify(sig, syscall.SIGINT, syscall.SIGKILL)

	stopCh := make(chan chan struct{})

	srvMux := http.NewServeMux()
	srvMux.HandleFunc("/getinfo", getinfo)
	go http.ListenAndServe(":19999", srvMux)

	go func(stopCh chan chan struct{}) {
		for {
			select {
			case tmpCh:=<-stopCh:
				fmt.Println(" processing tasks")
				time.Sleep(time.Second*time.Duration(2))
				fmt.Println("process over ")
				tmpCh <- struct{}{}
			}
		}
	}(stopCh)

	tmpCh := make(chan struct{})

	<-sig
	stopCh <- tmpCh
	<-tmpCh
	fmt.Println("close server ")
}
复制代码

上面 2 种方法都比较类似,都是使用通道来实现优雅关闭的功能,通道是 golang 天生的数据结构,咱们要用起来

使用 golang 标准解法 context

使用 golang 的 context ,能够更好的实现优雅关闭的问题

别以为 context 只会拿来传递数据,context 也是可以控制 子协程的生命周期的

func main() {
	sig := make(chan os.Signal)
	signal.Notify(sig, syscall.SIGINT, syscall.SIGKILL)

	stopCh := make(chan struct{})
    // 创建一个上下文
	ctx,cancle := context.WithCancel(context.Background())

	srvMux := http.NewServeMux()
	srvMux.HandleFunc("/getinfo", getinfo)
	go http.ListenAndServe(":19999", srvMux)

	go func(ctx context.Context,stopCh chan struct{}) {
		for {
			select {
			case <-ctx.Done():
				fmt.Println(" processing tasks")
				time.Sleep(time.Second*time.Duration(2))
				fmt.Println("process over ")
				stopCh <- struct{}{}
			}
		}
	}(ctx,stopCh)

	<-sig
	cancle()
	<-stopCh
	fmt.Println("close server ")
}
复制代码

此处我们使用 context 的方式,当主协程关闭上下文的时候,子协程就会从通道到读取到数据,进而进行优雅关闭,我们可以看到源码,ctx.Done() 的返回值也是一个通道

主协程等待所有子协程优雅关闭实现方法

上面我们说到的都是主协程等待 1 个子协程优雅关闭后,自己关闭程序

那么实际工作中肯定是不止一个协程的,咱们要做的优雅,那就优雅到底 ,此处我们的处理方式是 golang 中 context + sync.WaitGroup 的方式来实现

func main() {
	sig := make(chan os.Signal)
	signal.Notify(sig, syscall.SIGINT, syscall.SIGKILL)
	ctx, cancle := context.WithCancel(context.Background())

	mywg := sync.WaitGroup{}
	// 控制 5 个子协程的声明周期
	mywg.Add(5)

	for i := 0; i < 5; i++ {
		go func(ctx context.Context) {
			defer mywg.Done()
			for {
				select {
				case <-ctx.Done():
					fmt.Println(" processing tasks")
					time.Sleep(time.Second * time.Duration(1))
					fmt.Println("process over ")
					return

				default:
					time.Sleep(time.Second * time.Duration(1))
				}
			}
		}(ctx)
	}

	<-sig
	cancle()
	// 等待所有的子协程都优雅关闭
	mywg.Wait()
	fmt.Println("close server ")
}
复制代码

上述代码中,我们使用 sync.WaitGroup 控制 5 个子协程的生命周期,当主协程收到中断信号后,cancle() 掉 ctx

每一个子协程都能从 ctx.Done() 读取到数据,自行处理完毕手中事情后

最终 defer mywg.Done() ,主协程 mywg.Wait() 等待所有协程都优雅关闭后,自己也关闭了自己的程序

验证效果

# go run main.go
^C processing tasks
processing tasks
processing tasks
processing tasks
processing tasks
process over
process over
process over
process over
process over
close server
复制代码

以上就是从一个不会优雅关闭到学会常用优雅关闭方法的简单路径,希望对你有用哦

欢迎点赞,关注,收藏

朋友们,你的支持和鼓励,是我坚持分享,提高质量的动力

好了,本次就到这里

技术是开放的,我们的心态,更应是开放的。拥抱变化,向阳而生,努力向前行。

我是小魔童哪吒,欢迎点赞关注收藏,下次见~

文章分类
后端
文章标签