Comment utiliser le multi-processus dans Go ?

Avec l'amélioration des performances des ordinateurs et la popularité des processeurs multicœurs, la programmation multi-processus est progressivement devenue un élément indispensable du domaine de la programmation moderne. Dans le langage Go, la programmation multi-processus est également très simple à mettre en œuvre. Cet article explique comment utiliser le multi-processus dans Go.

1. Goroutines
En langage Go, la programmation simultanée peut être réalisée via Goroutines. "Goroutine" peut être considéré comme un "thread léger" dans le langage Go. Les goroutines sont planifiées par le runtime Go, et non par le système d'exploitation. Par conséquent, dans le langage Go, l’utilisation de Goroutines pour ouvrir plusieurs threads n’entraîne pas trop de surcharge. Comme indiqué ci-dessous, voici un exemple simple d'utilisation de Goroutines :

package main

import (
    "fmt"
    "time"
)

func main() {
    go task1()
    go task2()
    time.Sleep(3*time.Second)
}

func task1() {
    for i := 1; i <= 5; i++ {
        fmt.Println("Task 1: ", i)
        time.Sleep(time.Second)
    }
}

func task2() {
    for i := 1; i <= 5; i++ {
        fmt.Println("Task 2: ", i)
        time.Sleep(time.Second)
    }
}

Dans l'exemple ci-dessus, le programme utilise deux Goroutines pour démarrer deux tâches, task1 et task2. Chaque tâche affichera son propre numéro, puis s'arrêtera pendant une seconde. Le programme utilise enfin time.Sleep(3*time.Second) et attend trois secondes avant la fin du programme pour s'assurer que les deux tâches sont terminées.

2. Utilisez le package os pour implémenter plusieurs processus
Dans le langage Go, vous pouvez utiliser la fonction StartProcess dans le package os pour démarrer un nouveau processus. La fonction StartProcess reçoit le chemin d'un fichier exécutable en tant que paramètre, et cette fonction exécutera le fichier exécutable en tant que nouveau processus. Dans le même temps, grâce aux paramétrages de la fonction StartProcess, le stdin, stdout ou stderr du programme en cours peut être redirigé vers le programme démarré. Dans l'exemple suivant, démarrez une commande externe et laissez le programme attendre la fin de l'exécution de la commande :

package main

import (
    "fmt"
    "os"
    "os/exec"
)

func main() {
    binary, lookErr := exec.LookPath("ls")
    if lookErr != nil {
        panic(lookErr)
    }

    args := []string{"ls", "-a", "-l", "-h"}

    env := os.Environ()

    execErr := syscall.Exec(binary, args, env)
    if execErr != nil {
        panic(execErr)
    }
}

Dans l'exemple ci-dessus, le programme utilise la fonction exec.LookPath pour trouver la commande ls qui peut être exécutée dans le système et se prépare à démarrer un nouveau processus. Dans le même temps, en définissant la variable args, les paramètres qui doivent être transmis à la commande après le démarrage du processus sont définis. Enfin, utilisez la fonction syscall.Exec pour démarrer le nouveau processus.

3. Utiliser la communication par canal
Dans le langage Go, les canaux peuvent être utilisés pour le transfert de données et la coordination entre différents processus. L'utilisation de canaux peut éviter les conditions de concurrence provoquées par les processus accédant à la même ressource. Dans l'exemple suivant, l'utilisation de la communication par canal entre trois processus différents est illustrée :

package main

import (
    "fmt"
    "os"
    "strconv"
)

func main() {
    c := make(chan int)
    go pinger(c)
    go ponger(c)
    go printer(c)

    var input string
    fmt.Scanln(&input)
}

func pinger(c chan<- int) { // send only channel
    for i := 0; ; i++ {
        c <- i
    }
}

func ponger(c chan<- int) { // send only channel
    for i := 0; ; i++ {
        c <- i*2
    }
}

func printer(c <-chan int) { // receive only channel
    for {
        fmt.Println("Received value: ", <-c)
    }
}

Dans l'exemple ci-dessus, trois Goroutines sont activées dans le programme. Les fonctions pinger et ponger utilisent un type de canal « envoi uniquement » pour envoyer des données à la fonction d'imprimante. La fonction d'imprimante utilise un type de canal « réception uniquement » et utilise une boucle infinie pour lire en continu les données du canal et imprimer la sortie.

Résumé
Le langage Go offre une variété de façons d'utiliser le multi-processus, notamment en utilisant Goroutines, os.StartProcess et la communication par canal, etc. L'utilisation de ces méthodes permet de mieux utiliser la puissance de calcul des processeurs multicœurs et d'améliorer les performances et la simultanéité des programmes. Dans le même temps, chaque méthode présente ses avantages et ses inconvénients. Dans le processus de programmation proprement dit, différentes méthodes doivent être sélectionnées en fonction de scénarios spécifiques.

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!