Wie verwende ich Multiprozesse in Go?

Mit der Verbesserung der Computerleistung und der Beliebtheit von Mehrkernprozessoren ist die Mehrprozessprogrammierung nach und nach zu einem unverzichtbaren Bestandteil des modernen Programmierbereichs geworden. In der Go-Sprache ist auch die Multiprozessprogrammierung sehr einfach zu implementieren. In diesem Artikel wird die Verwendung von Multiprozessen in Go vorgestellt.

1. Goroutinen
In der Go-Sprache kann gleichzeitiges Programmieren durch Goroutinen erreicht werden. „Goroutine“ kann als „leichter Thread“ in der Go-Sprache angesehen werden. Goroutinen werden von der Go-Laufzeit geplant, nicht vom Betriebssystem. Daher verursacht die Verwendung von Goroutinen zum Öffnen mehrerer Threads in der Go-Sprache keinen allzu großen Overhead. Wie unten gezeigt, ist ein einfaches Beispiel für die Verwendung von Goroutinen:

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)
    }
}

Im obigen Beispiel verwendet das Programm zwei Goroutinen, um zwei Aufgaben zu starten, Aufgabe1 und Aufgabe2. Jede Aufgabe gibt ihre eigene Nummer aus und pausiert dann für eine Sekunde. Das Programm verwendet schließlich time.Sleep(3*time.Second) und wartet drei Sekunden, bevor das Programm endet, um sicherzustellen, dass die beiden Aufgaben abgeschlossen sind.

2. Verwenden Sie das Betriebssystempaket, um mehrere Prozesse zu implementieren.
In der Go-Sprache können Sie die StartProcess-Funktion im Betriebssystempaket verwenden, um einen neuen Prozess zu starten. Die StartProcess-Funktion empfängt den Pfad einer ausführbaren Datei als Parameter und diese Funktion führt die ausführbare Datei als neuen Prozess aus. Gleichzeitig kann durch die Parametereinstellung der StartProcess-Funktion stdin, stdout oder stderr des aktuellen Programms auf das gestartete Programm umgeleitet werden. Starten Sie im folgenden Beispiel einen externen Befehl und lassen Sie das Programm warten, bis die Befehlsausführung abgeschlossen ist:

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)
    }
}

Im obigen Beispiel verwendet das Programm die Funktion exec.LookPath, um den ls-Befehl zu finden, der im System ausgeführt werden kann bereitet sich darauf vor, einen neuen Prozess zu starten. Gleichzeitig werden durch die Definition der Variablen args die Parameter festgelegt, die nach dem Starten des Prozesses an den Befehl übergeben werden müssen. Verwenden Sie abschließend die Funktion syscall.Exec, um den neuen Prozess zu starten.

3. Kanalkommunikation nutzen
In der Go-Sprache können Kanäle für die Datenübertragung und Koordination zwischen verschiedenen Prozessen verwendet werden. Durch die Verwendung von Kanälen können Race Conditions vermieden werden, die durch Prozesse verursacht werden, die auf dieselbe Ressource zugreifen. Im folgenden Beispiel wird die Verwendung der Kanalkommunikation zwischen drei verschiedenen Prozessen gezeigt:

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)
    }
}

Im obigen Beispiel sind drei Goroutinen im Programm aktiviert. Die Funktionen „pinger“ und „ponger“ verwenden einen Kanal vom Typ „Nur Senden“, um Daten an die Druckerfunktion zu senden. Die Druckerfunktion verwendet einen Kanal vom Typ „Nur Empfangen“ und verwendet eine Endlosschleife, um kontinuierlich Daten aus dem Kanal zu lesen und die Ausgabe zu drucken.

Zusammenfassung
Die Go-Sprache bietet eine Vielzahl von Möglichkeiten zur Verwendung mehrerer Prozesse, einschließlich der Verwendung von Goroutinen, os.StartProcess und Kanalkommunikation usw. Mit diesen Methoden kann die Rechenleistung von Mehrkernprozessoren besser genutzt und die Programmleistung und Parallelität verbessert werden. Gleichzeitig hat jede Methode ihre eigenen Vor- und Nachteile. Im eigentlichen Programmierprozess müssen je nach Szenario unterschiedliche Methoden ausgewählt werden.

Das obige ist der detaillierte Inhalt vonWie verwende ich Multiprozesse in Go?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!