Planification des tâches et allocation multi-tâches en langage Go

#🎜🎜Le langage #Go est un langage de programmation efficace, concis et simultané. Sa puissante prise en charge de la concurrence et ses threads légers sont une caractéristique majeure du langage Go. Le langage Go fournit également des mécanismes correspondants pour la mise en œuvre de la planification temporelle et de l'allocation multitâche. Cet article présentera la planification des tâches et l'allocation multitâche dans le langage Go.

1. Planification des tâches

La planification des tâches en langage Go peut être implémentée à l'aide du package time Les fonctions NewTicker, NewTimer et Sleep fournies par ce package peuvent nous aider. remplir différentes exigences de planification. En prenant NewTicker comme exemple, son prototype de fonction est le suivant :

func NewTicker(d Duration) *Ticker

Le paramètre d représente l'intervalle de temps de chaque ticker, et Ticker renvoie un canal. Les événements temporels peuvent y être lus. Voici un exemple simple :

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.NewTicker(time.Millisecond * 500)
    defer t.Stop()
    for i := 0; i < 10; i++ {
        <-t.C
        fmt.Println("tick")
    }
}

Dans le code ci-dessus, nous utilisons NewTicker pour créer un ticker qui se déclenche toutes les 500 millisecondes, et utilisons une boucle for pour accepter les messages du canal et imprimer "tick".

Bien sûr, nous pouvons également utiliser NewTimer pour créer un planning de travail unique. Le prototype de la fonction est le suivant :

func NewTimer(d Duration) *Timer#🎜. 🎜## 🎜🎜#Le paramètre d représente la durée d'attente, et Timer renvoie un canal dans lequel les événements temporels peuvent être lus. Voici un exemple simple :

package main

import (
    "fmt"
    "time"
)

func main() {
    fmt.Println("starting...")
    t := time.NewTimer(time.Second)
    <-t.C
    fmt.Println("done")
}

Dans le code ci-dessus, nous utilisons NewTimer pour créer un timer d'une durée de 1 seconde et attendons que le timer se termine dans le canal. Cet extrait de code attendra 1 seconde, puis affichera « terminé ».

2. Distribution multitâche

Le langage Go prend intrinsèquement en charge la programmation simultanée, nous pouvons donc facilement mettre en œuvre une distribution multitâche. Voici un exemple simple :

package main

import (
    "fmt"
    "time"
)

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Printf("worker %d processing job %d
", id, j)
        time.Sleep(time.Second)
        results <- j * 2
    }
}

func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)

    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    for j := 1; j <= 5; j++ {
        jobs <- j
    }
    close(jobs)

    for a := 1; a <= 5; a++ {
        <-results
    }
}

Dans le code ci-dessus, nous avons implémenté un répartiteur de tâches simple, créé 3 coroutines de travail et attribué des tâches aux canaux. Chaque coroutine de travail lit les tâches du canal, exécute les tâches et renvoie les résultats au canal de résultats. La fonction principale attend que tous les résultats soient renvoyés.

Résumé

La prise en charge efficace de la concurrence du langage Go nous offre une planification pratique des tâches et une mise en œuvre de l'allocation multitâche. Grâce aux fonctions NewTicker, NewTimer et Sleep du package time, nous pouvons facilement mettre en œuvre une planification temporelle. Grâce aux coroutines et aux canaux, nous pouvons facilement mettre en œuvre une distribution multitâche. Ces fonctionnalités nous permettent de mettre en œuvre plus rapidement la programmation simultanée et l'allocation des tâches lors de l'écriture quotidienne du code, et d'améliorer l'efficacité et les performances du code.

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!