Mécanisme d'expiration et d'annulation des Goroutines et des chaînes dans Golang

Mécanisme d'expiration et d'annulation des Goroutines et des canaux dans Golang

Dans Golang, les Goroutines et les canaux sont des composants importants de la programmation simultanée. Les Goroutines sont une implémentation de threads légers dans le langage Go qui nous permettent d'exécuter facilement plusieurs tâches simultanément. Les canaux sont le mécanisme de communication entre les Goroutines, utilisé pour transférer des données et synchroniser les tâches.

Dans la programmation concurrente réelle, nous devons parfois contrôler le temps d'exécution des Goroutines, ou annuler l'exécution des Goroutines sous certaines conditions spécifiques. Pour réaliser ces fonctions, Golang fournit des mécanismes de délai d'attente et d'annulation. Ci-dessous, nous présenterons en détail comment utiliser ces mécanismes dans Golang et donnerons des exemples de code correspondants.

1. Le mécanisme de délai d'attente de Goroutines

Le mécanisme de délai d'attente de Goroutines peut garantir que les tâches sont exécutées dans le délai spécifié. Si la tâche n'est pas terminée après le délai spécifié, la tâche sera annulée en raison d'un délai d'attente. Golang fournit le package context pour implémenter cette fonction. Voici un exemple de code qui utilise le mécanisme de délai d'attente de Goroutines : context 包来实现这个功能。下面是一个使用 Goroutines 超时机制的示例代码：

package main

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

func worker(ctx context.Context) {
    for {
        select {
        case <-ctx.Done():
            fmt.Println("任务被取消，退出 Goroutine")
            return
        default:
            fmt.Println("正在执行任务...")
            time.Sleep(1 * time.Second)
        }
    }
}

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

    go worker(ctx)

    time.Sleep(10 * time.Second)
}

在上面的代码中，我们使用 context.WithTimeout 函数创建了一个具有 5 秒超时时间的上下文对象，然后调用 go worker(ctx) 启动了一个 Goroutine 执行任务。在任务执行过程中，通过 select 语句监听 ctx.Done() 通道，如果收到取消信号则退出 Goroutine。

注意，在 main 函数中我们通过 time.Sleep(10 * time.Second) 设置了一个 10 秒等待，这是为了确保 Goroutine 执行超时。运行以上代码，我们可以观察到在 5 秒超时时间到达后，worker Goroutine 会收到取消信号并退出。

2. Goroutines 的取消机制

Goroutines 的取消机制可以在特定条件下取消执行中的任务。我们同样可以使用 context 包来实现这个功能。看下面的代码示例：

package main

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

func worker(ctx context.Context) {
    for {
        select {
        case <-ctx.Done():
            fmt.Println("任务被取消，退出 Goroutine")
            return
        default:
            fmt.Println("正在执行任务...")
            time.Sleep(1 * time.Second)
        }
    }
}

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

    go worker(ctx)

    time.Sleep(5 * time.Second)

    cancel()
    fmt.Println("取消任务...")
    time.Sleep(2 * time.Second)
}

在上面的代码中，我们使用 context.WithCancel 函数创建了一个取消上下文对象，然后调用 go worker(ctx) 启动了一个 Goroutine 执行任务。在任务执行过程中，通过 select 语句监听 ctx.Done() 通道，如果收到取消信号则退出 Goroutine。

在 main 函数中，我们通过 time.Sleep(5 * time.Second) 设置了一个 5 秒等待，然后调用 cancel() 取消任务。运行以上代码，我们可以观察到在调用 cancel() 后，worker Goroutine 会立即收到取消信号并退出。

总结：

通过上述代码示例，我们学习了 Golang 中 Goroutines 和 Channels 的超时和取消机制。通过使用 contextrrreee

Dans le code ci-dessus, nous utilisons la fonction context.WithTimeout pour créer un objet contextuel avec un délai d'attente de 5 secondes, puis appelons go worker(ctx) démarre une tâche d'exécution Goroutine. Pendant l'exécution de la tâche, écoutez le canal ctx.Done() via l'instruction select et quittez Goroutine si un signal d'annulation est reçu.

Notez que dans la fonction main, nous définissons une attente de 10 secondes jusqu'à time.Sleep(10 * time.Second), ce qui permet de garantir que les temps d'exécution de Goroutine dehors. En exécutant le code ci-dessus, nous pouvons observer qu'une fois le délai d'attente de 5 secondes atteint, le worker Goroutine recevra un signal d'annulation et quittera. 🎜

🎜Mécanisme d'annulation des Goroutines 🎜🎜🎜Le mécanisme d'annulation des Goroutines peut annuler l'exécution de tâches dans des conditions spécifiques. Nous pouvons également utiliser le package context pour réaliser cette fonction. Regardez l'exemple de code ci-dessous : 🎜rrreee🎜Dans le code ci-dessus, nous utilisons la fonction context.WithCancel pour créer un objet de contexte d'annulation, puis appelons go worker(ctx) pour démarrer Créez une Goroutine pour effectuer des tâches. Pendant l'exécution de la tâche, écoutez le canal ctx.Done() via l'instruction select et quittez Goroutine si un signal d'annulation est reçu. 🎜🎜Dans la fonction main, nous définissons une attente de 5 secondes jusqu'à time.Sleep(5 * time.Second) puis appelons cancel() code> code> Annuler la tâche. En exécutant le code ci-dessus, nous pouvons observer qu'après avoir appelé <code>cancel(), le worker Goroutine recevra immédiatement le signal d'annulation et quittera. 🎜🎜Résumé : 🎜🎜Grâce aux exemples de code ci-dessus, nous avons appris le mécanisme de délai d'attente et d'annulation des Goroutines et des canaux dans Golang. En utilisant le package context, nous pouvons implémenter des opérations d'expiration et d'annulation de tâches pour mieux contrôler l'exécution des tâches simultanées. Ceci est très utile dans la programmation concurrente réelle et peut garantir la bonne exécution des tâches et la libération des ressources. 🎜🎜J'espère que cet article vous aidera à comprendre le mécanisme de délai d'attente et d'annulation des Goroutines et des canaux dans Golang, et j'espère que vous pourrez l'utiliser de manière flexible dans le développement réel. Merci d'avoir lu! 🎜

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!