Golang ferme l'invite

Golang est un langage de programmation très puissant qui fonctionne bien dans la programmation réseau, le calcul parallèle et le traitement du Big Data. Cependant, dans le développement quotidien, nous pouvons rencontrer des problèmes ennuyeux, dont l'un concerne les invites de fermeture.

Dans Golang, lorsque nous souhaitons arrêter un programme ou un serveur, nous pouvons être dérangés par des invites inutiles. Ces conseils peuvent nous être utiles dans certaines situations, mais dans d’autres cas, ils ne constituent qu’une perte de temps et d’énergie.

Alors, comment désactiver ces invites dans Golang ? Ci-dessous, je vais vous présenter trois méthodes en détail.

1. Utilisation du package os/signal

Dans Golang, nous pouvons utiliser le package os/signal pour gérer les signaux. Les signaux sont des demandes d'interruption envoyées par le système d'exploitation à un processus. Ils peuvent être utilisés pour avertir le programme d'effectuer certaines actions dans des conditions spécifiques. Dans ce cas, nous pouvons utiliser le package de signaux pour intercepter le signal et effectuer les opérations dont nous avons besoin.

Plus précisément, en Golang, nous pouvons utiliser la méthode signal.Notify() pour écouter un ou plusieurs signaux spécifiques et appeler une fonction de traitement lorsque le signal est reçu. Ensuite, dans la fonction de gestionnaire, nous pouvons effectuer l'action dont nous avons besoin, comme arrêter un programme ou un serveur.

Ce qui suit est un exemple de code :

package main

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

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

    go func() {
        sig := <-sigs
        fmt.Println()
        fmt.Println(sig)
        fmt.Println("Closing...")
        // 在这里执行关闭操作
        os.Exit(0)
    }()
    // 运行你的应用程序
}

Dans le code ci-dessus, nous surveillons deux signaux système (SIGINT et SIGTERM) via le package os/signal et le package syscall. Lorsque nous appuyons sur Ctrl+C dans le terminal ou envoyons le signal SIGTERM au programme, le canal de signal recevra le signal, la fonction de traitement sera déclenchée, puis nous effectuerons les opérations dont nous avons besoin dans la fonction de traitement.

2. Utilisation de os.Interrupt

Golang fournit un moyen plus simple d'arrêter un programme ou un serveur, en utilisant os.Interrupt. Cette méthode capture en fait le signal d'interruption dans l'application et effectue l'opération souhaitée lorsque le signal est reçu.

Voici un exemple de code :

package main

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

func main() {
    done := make(chan bool, 1)

    go func() {
        sig := make(chan os.Signal, 1)
        signal.Notify(sig, os.Interrupt, syscall.SIGTERM)

        <-sig
        fmt.Println("Closing...")
        // 在这里执行关闭操作
        done <- true
    }()
    // 运行你的应用程序

    <-done
}

Dans le code ci-dessus, nous créons un canal terminé pour nous avertir que le programme s'est arrêté. Nous écoutons également deux signaux (os.Interrupt et syscall.SIGTERM) dans la goroutine, exécutons une fonction de traitement lorsque le signal est reçu, puis envoyons une valeur vraie au canal terminé pour terminer le programme.

Enfin, on attend le signal du canal terminé dans la fonction principale.

3. Utiliser context.Context

Enfin, nous présentons comment utiliser context.Context pour arrêter un programme ou un serveur. Le cœur de cette méthode est de configurer un contexte avec une fonction d'annulation. Lorsque nous voulons arrêter le programme ou le serveur, il suffit d'appeler la fonction d'annulation.

Voici un exemple de code :

package main

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

func main() {
    ctx, cancel := context.WithCancel(context.Background())

    mux := http.NewServeMux()

    // 当访问/stop时，调用cancel函数
    mux.HandleFunc("/stop", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusOK)
        fmt.Println("Closing...")
        cancel()
    })

    server := &http.Server{
        Addr:    ":8080",
        Handler: mux,
    }

    go func() {
        sigs := make(chan os.Signal, 1)
        signal.Notify(sigs, os.Interrupt, syscall.SIGTERM)

        // 当收到信号时，调用cancel函数
        <-sigs
        fmt.Println("Closing...")
        cancel()
    }()

    // 启动服务器
    go func() {
        fmt.Println("Starting server on :8080")
        if err := server.ListenAndServe(); err != http.ErrServerClosed {
            fmt.Printf("HTTP server ListenAndServe: %v
", err)
        }
    }()

    <-ctx.Done()
    // 在这里执行关闭操作
    fmt.Println("Server stopped")
    server.Shutdown(context.Background())
    time.Sleep(time.Second * 2)
}

Dans le code ci-dessus, nous utilisons un contexte avec une fonction d'annulation. Nous avons également créé un serveur HTTP, et lorsque nous accédons à /stop, la fonction d'annulation est appelée pour arrêter le serveur. Dans goroutine, nous écoutons les signaux reçus par le programme et appelons la fonction d'annulation lorsque le signal est reçu.

Enfin, nous attendons le signal ctx.Done() dans la fonction principale (c'est-à-dire le signal lorsque la fonction d'annulation est appelée), effectuons l'opération d'arrêt lorsque le signal est reçu et enfin arrêtons le serveur.

Résumé

Lors de l'arrêt d'un programme ou d'un serveur dans Golang, nous pouvons utiliser le package os/signal, os.Interrupt, context.Context et d'autres méthodes. Quelle que soit la méthode, il suffit d'effectuer l'opération correspondante lors de la réception du signal d'interruption. La méthode à choisir dépend de notre type d’application et de nos besoins de développement.

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!