événement d'arrêt du programme Golang-Golang-php.cn

Lors de l'écriture de programmes Golang, nous devons souvent gérer les événements d'arrêt du programme. En particulier dans les programmes de longue durée, l'arrêt rapide et efficace du programme peut éviter les fuites de ressources et la corruption des données. Cet article explique comment gérer correctement les événements d'arrêt de programme dans Golang.

1. Déclenchement de l'événement d'arrêt du programme

Lorsqu'une application Golang reçoit un signal d'interruption du système, l'événement d'arrêt du programme sera déclenché. Sous les systèmes Linux, les signaux d'interruption peuvent être déclenchés manuellement par l'utilisateur ou générés automatiquement par le système, tels que Ctrl+C, Ctrl+Break, Kill et d'autres signaux.

2. La nécessité d'un arrêt progressif du programme

Pendant l'exécution du programme, nous devons souvent maintenir et occuper certaines ressources, telles que les connexions à la base de données, les descripteurs de fichiers , minuteries, etc. Lorsque nous ne libérons pas ces ressources à temps, des problèmes tels que des fuites de mémoire ou une corruption de données peuvent en résulter. L'événement d'arrêt du programme joue un rôle dans la gestion de ces problèmes.

Il existe de nombreuses façons de gérer les événements d'arrêt d'un programme, mais la plus courante consiste à fermer le programme en douceur.

3. Comment arrêter le programme en douceur

Il y a trois étapes pour fermer le programme en douceur :

Enregistrer l'arrêt Fonction d'écoute d'événement

La fonction d'écoute d'événement de clôture enregistrée est implémentée via le package de signaux de Golang. Après l'enregistrement, lorsque le programme reçoit un événement d'arrêt, il appellera la fonction d'écoute pour traitement.

Ce qui suit est un programme simple qui montre comment enregistrer une fonction d'écoute pour l'événement d'arrêt.

package main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"
    "time"
)

func main() {
    // 注册程序关闭监听函数
    signals := make(chan os.Signal, 1)
    signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM)

    // 等待程序关闭事件
    <-signals
    fmt.Println("收到程序关闭事件，开始优雅关闭程序")

    // 在此处添加程序关闭前的清理操作
    time.Sleep(time.Second)
    fmt.Println("程序已关闭")
}

Copier après la connexion

Dans le code ci-dessus, nous avons enregistré les signaux SIGINT et SIGTERM via la fonction signal.Notify() Fonction d'écoute, lorsque le programme reçoit ces deux signaux, il lancera la fonction d'écoute. signal.Notify()函数注册了 SIGINT 和 SIGTERM 信号的监听函数，当程序收到这两个信号时，就会启动监听函数。

触发关闭事件

在程序中，我们可以通过任何方式触发关闭事件。在最简单的情况下，我们可以发出 Ctrl + C 信号。但在实际场景中，我们可能需要以其他方式触发关闭事件。例如，我们可能会开启一个协程来定期检查关闭事件是否已经触发，以便及时优雅关闭程序。

下面是一个程序，展示了如何通过协程实现定期检查关闭事件：

package main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"
    "time"
)

func main() {
    signals := make(chan os.Signal, 1)
    signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM)

    go func() {
        for {
            select {
            case <-signals:
                fmt.Println("收到程序关闭事件，开始优雅关闭程序")
                time.Sleep(time.Second)
                fmt.Println("程序已关闭")
                os.Exit(0)
            }
        }
    }()

    fmt.Println("程序已启动")
    for {
        time.Sleep(time.Second)
        fmt.Println("程序运行中......")
    }
}

Copier après la connexion

在上述代码中，我们通过启动一个协程来实现定时检查程序关闭事件。当协程收到关闭事件时，会进行程序优雅关闭操作。

程序优雅关闭前的清理工作

在程序优雅关闭前，我们可能需要完成以下清理工作：

关闭数据库连接；
清理缓存；
关闭文件IO；
等待协程退出；

这些操作有助于确保程序的稳定性和数据的完整性。在进行这些清理工作时，我们可能需要考虑到以下两个问题：

顺序问题：需要按照某种顺序进行清理工作；
超时问题：当我们发现某个清理工作不能及时完成时，我们该如何处理？

超时问题一般可以通过 Golang 的 time 包进行处理，例如通过 time.WithTimeout()

Dans le programme, nous pouvons déclencher l'événement de clôture de n'importe quelle manière. Dans le cas le plus simple, on peut émettre le signal Ctrl + C. Mais dans des scénarios réels, nous devrons peut-être déclencher l’événement d’arrêt par d’autres moyens. Par exemple, nous pourrions démarrer une coroutine pour vérifier régulièrement si l'événement d'arrêt a été déclenché afin que le programme puisse être arrêté correctement et en temps opportun.

Ce qui suit est un programme qui montre comment implémenter une vérification régulière des événements d'arrêt via des coroutines :

package main

import (
    "context"
    "fmt"
    "os"
    "os/signal"
    "syscall"
    "time"
)

func main() {
    signals := make(chan os.Signal, 1)
    signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM)

    go func() {
        for {
            select {
            case <-signals:
                fmt.Println("收到程序关闭事件，开始优雅关闭程序")

                // 在此处添加程序关闭前的清理操作
                ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
                go cleanup(ctx)
                <-ctx.Done()

                time.Sleep(time.Second)
                fmt.Println("程序已关闭")
                os.Exit(0)
            }
        }
    }()

    fmt.Println("程序已启动")
    for {
        time.Sleep(time.Second)
        fmt.Println("程序运行中......")
    }
}

func cleanup(ctx context.Context) {
    fmt.Println("开始清理数据库连接")
    time.Sleep(time.Second * 3)
    fmt.Println("数据库连接已关闭")

    fmt.Println("开始清理缓存")
    time.Sleep(time.Second * 3)
    fmt.Println("缓存已清理完成")

    fmt.Println("开始清理文件IO")
    time.Sleep(time.Second * 3)
    fmt.Println("文件IO已关闭")

    fmt.Println("开始等待协程退出")
    time.Sleep(time.Second * 3)
    fmt.Println("协程已退出")
}

Copier après la connexion

Dans le code ci-dessus, nous implémentons le programme de vérification planifiée en démarrant une coroutine Fermer l'événement. Lorsque la coroutine reçoit un événement d'arrêt, le programme sera correctement fermé.

Travail de nettoyage avant que le programme ne s'arrête correctement

#🎜🎜#Fermer la connexion à la base de données #🎜🎜##🎜🎜#Vider le cache #🎜🎜##🎜🎜#Fermer le fichier IO #🎜🎜##🎜🎜#Attendez ; pour que la coroutine se termine ; #🎜🎜#

#🎜🎜#Problème de séquence : les travaux de nettoyage doivent être effectués dans un certain ordre #🎜🎜##🎜🎜# ; Problème de délai d'attente : Que devons-nous faire lorsque nous constatons qu'une certaine tâche de nettoyage ne peut pas être terminée à temps ? #🎜🎜#

time

time.WithTimeout()

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!