Golang définit le délai d'attente

Golang est un langage de programmation efficace et largement utilisé en développement dans divers domaines. Dans certains scénarios spécifiques, nous devons définir un délai d'attente pour éviter un blocage ou un blocage du programme. Dans cet article, je présenterai en détail comment Golang définit le délai d'attente et plusieurs façons de définir le délai d'attente.

1. Utiliser des canaux

Dans Golang, vous pouvez utiliser des canaux pour implémenter la fonction de délai d'attente. Nous pouvons définir un canal avec un paramètre de timeout et récupérer les données en fonction du délai d'attente après l'exécution du programme.

Par exemple, ce qui suit est un exemple de code simple :

package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan string, 1)

    go func() {
        time.Sleep(time.Second * 3)
        ch <- "task completed"
    }()

    select {
    case res := <-ch:
        fmt.Println(res)
    case <-time.After(time.Second * 2):
        fmt.Println("timeout")
    }
}

Nous pouvons voir qu'un canal avec un paramètre de délai d'attente est créé. Une fois le programme exécuté, une coroutine simultanée sera démarrée, ce qui prend 3 secondes pour exécuter la tâche. . temps. Dans l'instruction select, nous écoutons deux chaînes. Si les données sont reçues dans le délai imparti, c'est-à-dire que l'exécution de la tâche est terminée, le programme imprimera « tâche terminée ». Si aucune donnée n'est reçue dans le délai imparti, le programme imprimera "timeout".

2. Utiliser le contexte

Dans Golang, le package de contexte fournit une méthode pour transmettre les données de plage de requêtes, les signaux d'annulation et les délais d'attente. Nous pouvons utiliser la fonction WithTimeout pour créer un objet Context portant un timeout.

Par exemple, voici un exemple de code simple :

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), time.Second*2)
    defer cancel()

    go func(ctx context.Context) {
        time.Sleep(time.Second * 3)
        select {
        case <-ctx.Done():
            fmt.Println(ctx.Err())
        default:
            fmt.Println("task completed")
        }
    }(ctx)

    select {
    case <-ctx.Done():
        fmt.Println(ctx.Err())
    }
}

Dans cet exemple, nous utilisons la fonction WithTimeout pour créer un objet Context avec un timeout de 2 secondes. Dans la coroutine simultanée activée, nous bloquons et attendons 2 secondes. Si la tâche est terminée dans les 2 secondes, la coroutine affichera "tâche terminée", sinon elle affichera un message d'erreur de délai d'attente contextuel. Dans l'instruction select, nous écoutons le canal Done() de l'objet Context. Si le signal du canal Done() est reçu, le programme annulera la tâche et affichera un message d'erreur.

3. Utiliser Cancel

Dans certains cas spécifiques, nous pouvons avoir besoin d'annuler l'exécution d'une tâche en définissant la fonction d'annulation. Par exemple, dans un scénario où des données sont demandées au réseau, un délai d'attente peut être défini. Si aucune donnée n'est demandée dans le délai imparti, nous devons annuler la demande.

Par exemple, ce qui suit est un exemple de code simple :

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), time.Second*2)
    defer cancel()

    ch := make(chan string, 1)

    go func(ctx context.Context) {
        time.Sleep(time.Second * 3)
        ch <- "task completed"
    }(ctx)

    select {
    case res := <-ch:
        fmt.Println(res)
    case <-ctx.Done():
        fmt.Println(ctx.Err())
    }

    cancel()
}

Dans cet exemple, nous créons un objet Contexte portant un délai d'attente et démarrons une coroutine simultanée pour exécuter la tâche. Dans l'instruction select, nous surveillons le canal Done() de la tâche et les objets Context Si la tâche est terminée, "tâche terminée" sera affiché, sinon un message d'erreur de délai d'attente sera affiché. Appelez la fonction Cancel() à la fin du programme pour annuler l'exécution de la tâche. Si la tâche est terminée dans le délai imparti, le programme se terminera normalement. Sinon, le programme sera bloqué dans l'instruction select jusqu'à ce que la fonction Cancel() soit exécutée.

4. Utiliser la date limite

En plus d'utiliser la fonction WithTimeout, le package de contexte fournit également une autre méthode de délai d'attente, c'est-à-dire l'utilisation de la fonction WithDeadline. Contrairement à la fonction WithTimeout, le paramètre de la fonction WithDeadline est une date limite et non un délai d'attente. Lorsque la tâche est terminée avant la date limite, le programme se terminera normalement.

Par exemple, ce qui suit est un exemple de code simple :

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    ctx, cancel := context.WithDeadline(context.Background(), time.Now().Add(time.Second*2))
    defer cancel()

    go func(ctx context.Context) {
        time.Sleep(time.Second * 3)
        select {
        case <-ctx.Done():
            fmt.Println(ctx.Err())
        default:
            fmt.Println("task completed")
        }
    }(ctx)

    select {
    case <-ctx.Done():
        fmt.Println(ctx.Err())
    }
}

Dans cet exemple, nous utilisons la fonction WithDeadline pour créer un objet Context avec un délai de 2 secondes. Si la tâche est terminée avant la date limite, le programme affichera « tâche terminée », sinon il affichera un message d'erreur de délai d'attente. Dans l'instruction select, nous écoutons également le canal Done() de l'objet Context. Si un signal du canal Done() est reçu, le programme affichera un message d'erreur.

Résumé :

Golang propose plusieurs façons de définir des délais d'attente. En utilisant des méthodes telles que le canal, le contexte, l'annulation et la date limite, nous pouvons éviter les impasses ou les problèmes bloqués du programme et garantir l'efficacité et la stabilité du fonctionnement du programme. Dans le développement réel, en fonction des différents besoins et scénarios, nous pouvons choisir la méthode appropriée pour définir le délai d'attente.

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!