• Go 实现程序优雅退出

    在Go语言中，实现程序的优雅退出是一项重要的任务，特别是在涉及到HTTP服务器、gRPC服务器、以及其他后台工作的情况下。 

    在实际应用中，通常建议同时监听 os.Interrupt 和 syscall.SIGTERM，因为它们都是常见的终止信号，可以确保你的程序能够优雅地响应不同的关闭场景。例如，在生产环境中，系统管理员可能会使用 SIGTERM 来终止服务，而不是依赖于 Ctrl+C

    HTTP Server 平滑关闭

    Go 1.8及以上版本提供了 http.Server 结构的 Shutdown 方法，用于平滑关闭HTTP服务器。

    案例一： 

    1. package main
    2.  
    3. import (
    4. 	"context"
    5. 	"fmt"
    6. 	"log"
    7. 	"net/http"
    8. 	"os"
    9. 	"os/signal"
    10. 	"time"
    11. )
    12.  
    13. func main() {
    14. 	// 创建一个新的 ServeMux 对象，它是HTTP请求多路复用器，用于将不同的请求路由到不同的处理函数
    15. 	mux := http.NewServeMux()
    16. 	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
    17. 		w.Write([]byte("Hello, World!"))
    18. 	})
    19.  
    20. 	server := &http.Server{
    21. 		Addr:    ":8088", //监听端口
    22. 		Handler: mux,     //监听的处理器
    23. 	}
    24.  
    25. 	//监听并服务HTTP请求，可以想办法开一个8088端口来占用，比如在java起一个服务
    26. 	go func() {
    27. 		if err := server.ListenAndServe(); err != nil {
    28. 			if err != http.ErrServerClosed {
    29. 				// 处理监听失败的错误
    30. 				// 记录错误
    31. 				log.Printf("HTTP服务器失败: %v", err)
    32.  
    33. 				// 执行清理工作,如有必要
    34.  
    35. 				// 可选：尝试重启服务器
    36. 				time.Sleep(10 * time.Second) //等待10秒再重启
    37. 				if !attemptRestart(server) {
    38. 					//os.Exit(1) 将导致程序立即退出，并返回状态码 1 表示发生了错误。在实际应用中，你可能需要根据错误的性质和程序的设计来决定是否退出程序，或者采取其他的错误恢复策略
    39. 					// 优雅地退出程序
    40. 					os.Exit(1)
    41. 				}
    42. 			}
    43. 		}
    44. 	}()
    45.  
    46. 	// 等待中断信号来优雅地关闭服务器
    47. 	stop := make(chan os.Signal, 1)
    48. 	// 用 signal.Notify 来监听 os.Interrupt 信号，这是用户向程序发送中断信号（如Ctrl+C）时产生的信号
    49. 	signal.Notify(stop, os.Interrupt)
    50.  
    51. 	<-stop // 程序在此处阻塞，直到接收到一个中断信号
    52.  
    53. 	//当有中断信号来，创建一个带有超时的 context.Context 对象，超时时间为5秒
    54. 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    55. 	// 确保在函数返回时取消这个上下文，释放相关资源
    56. 	defer cancel()
    57.  
    58. 	//当接收到中断信号时，调用 server.Shutdown 方法并传入上面创建的 ctx 对象，以优雅地关闭服务器
    59. 	if err := server.Shutdown(ctx); err != nil {
    60. 		// 如果在关闭过程中出现错误
    61. 		fmt.Println("处理关闭服务器时的错误")
    62. 	}
    63. }
    64.  
    65. // attemptRestart 尝试重启服务器
    66. func attemptRestart(server *http.Server) bool {
    67. 	// 这里可以添加任何需要的清理或重启前的准备工作
    68. 	log.Println("正在尝试重新启动服务器。。。")
    69.  
    70. 	// 尝试重新启动服务器
    71. 	err := server.ListenAndServe()
    72. 	if err != nil && err != http.ErrServerClosed {
    73. 		log.Printf("无法重新启动服务器: %v", err)
    74. 		return false
    75. 	}
    76. 	log.Println("重启成功。。。")
    77. 	return true
    78. }

    案例二：持续监听 

    1. package main
    2.  
    3. import (
    4. 	"context"
    5. 	"fmt"
    6. 	"log"
    7. 	"net/http"
    8. 	"os"
    9. 	"os/signal"
    10. 	"time"
    11. )
    12.  
    13. func main() {
    14. 	// 创建一个新的 ServeMux 对象，它是HTTP请求多路复用器，用于将不同的请求路由到不同的处理函数
    15. 	mux := http.NewServeMux()
    16. 	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
    17. 		w.Write([]byte("Hello, World!"))
    18. 	})
    19.  
    20. 	server := &http.Server{
    21. 		Addr:    ":8088", //监听端口
    22. 		Handler: mux,     //监听的处理器
    23. 	}
    24.  
    25. 	go func() {
    26. 		// 等待中断信号来优雅地关闭服务器
    27. 		stop := make(chan os.Signal, 1)
    28. 		// 用 signal.Notify 来监听 os.Interrupt 信号，这是用户向程序发送中断信号（如Ctrl+C）时产生的信号
    29. 		signal.Notify(stop, os.Interrupt)
    30.  
    31. 		<-stop // 程序在此处阻塞，直到接收到一个中断信号
    32.  
    33. 		//当有中断信号来，创建一个带有超时的 context.Context 对象，超时时间为5秒
    34. 		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    35. 		// 确保在函数返回时取消这个上下文，释放相关资源
    36. 		defer cancel()
    37.  
    38. 		//当接收到中断信号时，调用 server.Shutdown 方法并传入上面创建的 ctx 对象，以优雅地关闭服务器
    39. 		if err := server.Shutdown(ctx); err != nil {
    40. 			// 如果在关闭过程中出现错误
    41. 			fmt.Println("处理关闭服务器时的错误")
    42. 		}
    43. 	}()
    44.  
    45. 	//监听并服务HTTP请求，可以想办法开一个8088端口来占用，比如在java起一个服务
    46. 	for {
    47. 		if err := server.ListenAndServe(); err != nil {
    48. 			if err != http.ErrServerClosed {
    49. 				// 处理监听失败的错误
    50. 				// 记录错误
    51. 				log.Printf("HTTP服务器失败: %v", err)
    52.  
    53. 				// 执行清理工作,如有必要
    54.  
    55. 				// 可选：尝试重启服务器
    56. 				time.Sleep(5 * time.Second) //等待10秒再重启
    57. 				attemptRestart(server)
    58.  
    59. 				//os.Exit(1) 将导致程序立即退出，并返回状态码 1 表示发生了错误。在实际应用中，你可能需要根据错误的性质和程序的设计来决定是否退出程序，或者采取其他的错误恢复策略
    60. 				// 优雅地退出程序
    61. 				//os.Exit(1)
    62. 			}
    63. 		}
    64. 	}
    65. }
    66.  
    67. // attemptRestart 尝试重启服务器
    68. func attemptRestart(server *http.Server) bool {
    69. 	// 这里可以添加任何需要的清理或重启前的准备工作
    70. 	log.Println("正在尝试重新启动服务器。。。")
    71.  
    72. 	// 尝试重新启动服务器
    73. 	err := server.ListenAndServe()
    74. 	if err != nil && err != http.ErrServerClosed {
    75. 		log.Printf("无法重新启动服务器: %v", err)
    76. 		return false
    77. 	}
    78. 	return true
    79. }
    gRPC Server 平滑关闭

    gRPC服务器的平滑关闭可以通过 GracefulStop 方法实现  

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. 	"google.golang.org/grpc"
    6. 	"google.golang.org/grpc/reflection"
    7. 	"log"
    8. 	"net"
    9. 	"os"
    10. 	"os/signal"
    11. 	"syscall"
    12. )
    13.  
    14. func main() {
    15. 	lis, err := net.Listen("tcp", ":50051")
    16. 	if err != nil {
    17. 		log.Fatalf("监听失败: %v", err)
    18. 	}
    19. 	s := grpc.NewServer()
    20. 	// 注册服务...（需要自己写）
    21.  
    22. 	// 在gRPC服务上启用反射服务
    23. 	//启用反射服务后，客户端可以使用 gRPC 反射 API 查询服务器支持的服务列表、服务下的方法列表等信息。
    24. 	//这对于开发和测试阶段非常有用，因为它允许客户端在没有预先定义 .proto 文件的情况下与服务器通信。
    25. 	reflection.Register(s)
    26.  
    27. 	// 监听系统关闭信号
    28. 	sigs := make(chan os.Signal, 1)
    29. 	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
    30.  
    31. 	go func() {
    32. 		<-sigs
    33. 		fmt.Println("收到停止信号，正在正常停止gRPC服务器。。。")
    34. 		s.GracefulStop() // 调用 GracefulStop 方法来平滑关闭服务器
    35. 	}()
    36.  
    37. 	//如果 s.Serve(lis) 调用成功，服务器将正常运行，等待和处理客户端的请求。
    38. 	//如果发生错误，比如监听出现问题或者服务器无法处理请求，err 变量将包含相应的错误信息
    39. 	if err := s.Serve(lis); err != nil {
    40. 		log.Fatalf("服务失败: %v", err)
    41. 	}
    42.  
    43. 	//go func() {
    44. 	//	if err := s.Serve(lis); err != nil {
    45. 	//		// 处理gRPC服务启动错误
    46. 	//	}
    47. 	//}()
    48. }

    在 gRPC 中，注册服务是指将服务的实现与 gRPC 服务器关联起来。在 Go 语言中，这通常通过调用服务接口的 RegisterXXXServer 方法来完成，其中 XXX 是服务名称。以下是注册服务的一般步骤：

    1. 定义服务接口： 首先，你需要定义服务接口，这通常在 .proto 文件中完成。例如，如果你有一个名为 Greeter 的服务，它将包含一个 SayHello 方法。

    2. 生成服务代码： 使用 protoc 编译器和 gRPC 插件为 Go 生成服务代码。这将生成两个文件：.pb.go 和 _grpc.pb.go。第一个文件包含消息类型的定义，第二个文件包含服务接口的定义。

    3. 创建服务实现： 创建一个结构体来实现服务接口。这个结构体需要实现 .proto 文件中定义的所有方法。

    4. 注册服务： 在你的主函数中，创建一个 gRPC 服务器实例，并使用生成的服务注册函数将服务实现注册到服务器上。

    下面是一个简单的示例，演示了如何注册一个名为 Greeter 的服务：

    假设你的 .proto 文件定义如下：

    1. syntax = "proto3";
    2.  
    3. package example;
    4.  
    5. // The greeter service definition.
    6. service Greeter {
    7.   // Sends a greeting
    8.   rpc SayHello (HelloRequest) returns (HelloReply) {}
    9. }
    10.  
    11. // The request message containing the user's name.
    12. message HelloRequest {
    13.   string name = 1;
    14. }
    15.  
    16. // The response message containing the greetings.
    17. message HelloReply {
    18.   string message = 1;
    19. }

     生成 Go 代码：

    protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative your_service.proto

     创建服务实现：

    1. package main
    2.  
    3. import (
    4. 	"context"
    5. 	"log"
    6.  
    7. 	"google.golang.org/grpc"
    8. 	pb "path/to/your_package" // 替换为你的包路径
    9. )
    10.  
    11. // server 是 GreeterServer 的实现。
    12. type server struct {
    13. 	pb.UnimplementedGreeterServer
    14. }
    15.  
    16. // SayHello 实现 GreeterServer 的 SayHello 方法。
    17. func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
    18. 	log.Printf("Received: %v", in.GetName())
    19. 	return &pb.HelloReply{Message: "Hello " + in.GetName()}, nil
    20. }

     在主函数中注册服务：

    1. func main() {
    2. 	lis, err := net.Listen("tcp", ":50051")
    3. 	if err != nil {
    4. 		log.Fatalf("failed to listen: %v", err)
    5. 	}
    6. 	defer lis.Close()
    7.  
    8. 	s := grpc.NewServer()
    9. 	pb.RegisterGreeterServer(s, &server{}) // 注册服务
    10.  
    11. 	if err := s.Serve(lis); err != nil {
    12. 		log.Fatalf("failed to serve: %v", err)
    13. 	}
    14. }

    在这个示例中，pb.RegisterGreeterServer 是由 protoc 生成的函数，用于将 server 实例注册到 gRPC 服务器上。pb 是你的包名，它是由 protoc 编译器根据 .proto 文件的包声明生成的。

    请确保将 "path/to/your_package" 替换为实际的包路径，这个路径指向包含你的 .proto 文件生成的 Go 代码的位置。

    Worker 协程平滑关闭

    对于worker协程的平滑关闭，可以使用 context.Context 实现  

    1. package main
    2.  
    3. import (
    4. 	"context"
    5. 	"fmt"
    6. 	"os"
    7. 	"os/signal"
    8. 	"sync"
    9. 	"time"
    10. )
    11.  
    12. func worker(ctx context.Context, wg *sync.WaitGroup) {
    13. 	defer wg.Done()
    14.  
    15. 	for {
    16. 		select {
    17. 		case <-ctx.Done():
    18. 			fmt.Println("worker收到停机信号")
    19. 			return
    20. 		default:
    21. 			// 执行工作任务
    22. 			fmt.Println("Working...")
    23. 			time.Sleep(time.Second)
    24. 		}
    25. 	}
    26. }
    27.  
    28. func main() {
    29. 	ctx, cancel := context.WithCancel(context.Background())
    30. 	var wg sync.WaitGroup
    31.  
    32. 	// 启动worker协程
    33. 	wg.Add(1)
    34. 	go worker(ctx, &wg)
    35.  
    36. 	// 等待中断信号来优雅地关闭worker协程
    37. 	stop := make(chan os.Signal, 1)
    38. 	signal.Notify(stop, os.Interrupt)
    39.  
    40. 	<-stop // 等待中断信号
    41. 	fmt.Println("正在关闭。。。")
    42.  
    43. 	// 发送关闭信号给worker协程
    44. 	cancel()
    45. 	wg.Wait()
    46. 	fmt.Println("关闭完成")
    47. }
    实现 `io.Closer` 接口的自定义服务平滑关闭

    实现 io.Closer 接口的服务可以通过调用 Close 方法进行平滑关闭 

     

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. 	"os"
    6. 	"os/signal"
    7. 	"sync"
    8. )
    9.  
    10. type MyService struct {
    11. 	mu sync.Mutex
    12. 	// 其他服务相关的字段
    13. }
    14.  
    15. // MyService 实现了 Close 方法，那么它就隐式地实现了 io.Closer 接口
    16. func (s *MyService) Close() error {
    17. 	s.mu.Lock()
    18. 	defer s.mu.Unlock()
    19.  
    20. 	// 执行关闭服务的操作
    21. 	fmt.Println("正在关闭MyService。。。")
    22. 	return nil
    23. }
    24.  
    25. func main() {
    26. 	service := &MyService{}
    27.  
    28. 	// 等待中断信号来优雅地关闭服务
    29. 	stop := make(chan os.Signal, 1)
    30. 	signal.Notify(stop, os.Interrupt)
    31.  
    32. 	<-stop // 等待中断信号
    33. 	fmt.Println("正在关闭。。。")
    34.  
    35. 	// 调用Close方法进行平滑关闭
    36. 	if err := service.Close(); err != nil {
    37. 		fmt.Println("关闭服务时出错:", err)
    38. 	}
    39.  
    40. 	fmt.Println("关闭完成")
    41. }

    以上是一些Golang中实现程序优雅退出的方法，具体的实现方式取决于你的应用程序结构和使用的库。在实际应用中，你可能需要组合使用这些方法以确保整个应用程序在退出时都能够平滑关闭。

    在实际项目中的应用(Gin) 

    平滑关闭会阻止新的请求进来，并等待目前正在进行的业务处理完成(此处取决于timeout设置的时间，如果设置的时间过短，请求未完成，就会"服务器被迫关闭:context deadline exceeded")

    1. package main
    2.  
    3. import (
    4. 	"context"
    5. 	"fmt"
    6. 	"github.com/gin-gonic/gin"
    7. 	"net/http"
    8. 	"os"
    9. 	"os/signal"
    10. 	"syscall"
    11. 	"time"
    12. )
    13.  
    14. func main() {
    15. 	r := gin.Default()
    16.  
    17. 	// 定义路由
    18. 	r.GET("/ping", func(c *gin.Context) {
    19. 		time.Sleep(5 * time.Second) //模拟业务处理时间
    20. 		c.String(http.StatusOK, "pong")
    21. 	})
    22.  
    23. 	// 创建 HTTP 服务器
    24. 	srv := &http.Server{Addr: ":8080", Handler: r}
    25.  
    26. 	// 等待中断信号来优雅地关闭服务
    27. 	stop := make(chan os.Signal, 1)
    28. 	signal.Notify(stop, os.Interrupt, syscall.SIGTERM)
    29.  
    30. 	// 在新的 Goroutine 中启动 HTTP 服务器
    31. 	go func() {
    32. 		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
    33. 			fmt.Printf("listen: %v\n", err)
    34. 			os.Exit(1)
    35. 		}
    36. 	}()
    37.  
    38. 	// 阻塞直到接收到停止信号
    39. 	<-stop
    40.  
    41. 	// 创建一个 10 秒的超时上下文
    42. 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    43. 	defer cancel()
    44.  
    45. 	// 优雅关闭 HTTP 服务器
    46. 	if err := srv.Shutdown(ctx); err != nil {
    47. 		fmt.Printf("无法正常关闭服务器: %v\n", err)
    48. 	}
    49.  
    50. 	fmt.Println("服务器正常关闭")
    51. }
    1. package main
    2.  
    3. import (
    4. 	"context"
    5. 	"log"
    6. 	"net/http"
    7. 	"os"
    8. 	"os/signal"
    9. 	"syscall"
    10. 	"time"
    11.  
    12. 	"github.com/gin-gonic/gin"
    13. )
    14.  
    15. func main() {
    16. 	r := gin.Default()
    17.  
    18. 	// 添加路由等设置...
    19. 	r.GET("/ping", func(c *gin.Context) {
    20. 		time.Sleep(5 * time.Second)
    21. 		c.JSON(http.StatusOK, gin.H{
    22. 			"message": "pong",
    23. 		})
    24. 	})
    25.  
    26. 	// 启动HTTP服务器
    27. 	srv := &http.Server{
    28. 		Addr:    ":8080",
    29. 		Handler: r,
    30. 	}
    31.  
    32. 	// 创建一个用于通知服务器关闭的channel
    33. 	done := make(chan bool)
    34.  
    35. 	go func() {
    36. 		// 监听中断信号，通常是Ctrl+C或Kill命令
    37. 		sig := make(chan os.Signal, 1)
    38. 		signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
    39. 		<-sig // 等待信号
    40.  
    41. 		// 收到信号后，给出日志提示
    42. 		log.Println("Shutdown Server ...")
    43.  
    44. 		// 调用Server的Shutdown方法，传入一个有超时上下文
    45. 		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    46. 		defer cancel()
    47. 		if err := srv.Shutdown(ctx); err != nil {
    48. 			log.Fatal("服务器被迫关闭:", err)
    49. 		}
    50. 		close(done)
    51. 	}()
    52.  
    53. 	// 启动HTTP服务
    54. 	log.Println("正在端口8080上启动服务器。。。")
    55. 	if err := srv.ListenAndServe(); err != http.ErrServerClosed {
    56. 		log.Fatalf("listen: %s\n", err)
    57. 	}
    58.  
    59. 	<-done // 等待直到shutdown完成
    60. 	log.Println("服务器已退出")
    61. }

     

  • 相关阅读:
    熬夜暴肝了三天三夜终于搞清Jmeter怎么连接MySQL数据库
    Java 全栈知识体系
    使用语音控制SU-03T播放单片机所检测到的温度
    狂神linux笔记5
    5周年，时过境迁，千变万化
    Kubernetes Pod配置：从基础到高级实战技巧
    android的rtmp直播推流（一） nginx服务器的搭建
    大数据平台搭建2024（一）
    常用xshell中使用的linux命令
    JavaScript数据结构与算法-排序全详解
  • 原文地址：https://blog.csdn.net/qq_39335595/article/details/139099249