Heim > Artikel > Backend-Entwicklung > Leitfaden zur gleichzeitigen Programmierung: Erkundung der Parallelität in der Golang-Standardbibliothek
Leitfaden zur gleichzeitigen Programmierung in der Golang-Standardbibliothek
Einführung:
Die gleichzeitige Programmierung ist ein wichtiges Mittel zur Lösung von Programmleistungsproblemen und zur effizienten Nutzung von Rechenressourcen. In der Programmiersprache Golang stehen zahlreiche Tools und Methoden für die gleichzeitige Programmierung zur Verfügung. In diesem Artikel werden einige gängige gleichzeitige Programmiertechniken in der Golang-Standardbibliothek vorgestellt und deren Verwendung und Vorsichtsmaßnahmen anhand spezifischer Codebeispiele veranschaulicht.
package main import ( "fmt" "time" ) func printNumbers() { for i := 0; i < 5; i++ { fmt.Printf("%d ", i) time.Sleep(time.Millisecond * 500) } } func printLetters() { for i := 'A'; i < 'F'; i++ { fmt.Printf("%c ", i) time.Sleep(time.Millisecond * 500) } } func main() { go printNumbers() // 启动一个Goroutine,打印数字 go printLetters() // 启动另一个Goroutine,打印字母 time.Sleep(time.Second * 3) // 等待两个Goroutine执行完毕 fmt.Println("Done") }
Im obigen Code haben wir zwei Funktionen printNumbers
bzw. printLetters
definiert und go
übergeben Das Schlüsselwort code> startet sie jeweils als zwei Goroutinen. Verwenden Sie die Funktion time.Sleep
, um zu warten, bis die beiden Goroutinen die Ausführung abgeschlossen haben. In den Ausgabeergebnissen können Sie sehen, dass Zahlen und Buchstaben abwechselnd ausgegeben werden. printNumbers
和printLetters
两个函数,并通过go
关键字将它们分别启动为两个Goroutine。通过time.Sleep
函数等待两个Goroutine执行完毕,可以看到输出结果中数字和字母是交替输出的。
package main import ( "fmt" "time" ) func worker(id int, jobs <-chan int, results chan<- int) { for job := range jobs { fmt.Printf("Worker %d started job %d ", id, job) time.Sleep(time.Second) fmt.Printf("Worker %d finished job %d ", id, job) results <- job * 2 } } func main() { numJobs := 5 jobs := make(chan int, numJobs) results := make(chan int, numJobs) numWorkers := 3 for w := 1; w <= numWorkers; w++ { go worker(w, jobs, results) } for j := 1; j <= numJobs; j++ { jobs <- j } close(jobs) for a := 1; a <= numJobs; a++ { result := <-results fmt.Println("Result:", result) } }
在上述代码中,我们定义了worker
函数,该函数用于接收jobs通道传入的数字,并进行相应的处理,结果通过results通道返回。在主函数中,我们分别创建了jobs和results两个通道,并将jobs通道传递给三个Goroutine执行。然后,通过for循环向jobs通道发送5个作业,并关闭通道。最后,通过for循环接收results通道的返回结果并输出。
sync
包提供了WaitGroup类型来实现这个功能。下面是一个使用WaitGroup的示例:package main import ( "fmt" "sync" "time" ) func worker(id int, wg *sync.WaitGroup) { defer wg.Done() fmt.Printf("Worker %d starting ", id) time.Sleep(time.Second) fmt.Printf("Worker %d done ", id) } func main() { var wg sync.WaitGroup numWorkers := 3 wg.Add(numWorkers) for w := 1; w <= numWorkers; w++ { go worker(w, &wg) } wg.Wait() fmt.Println("All workers done") }
在上述代码中,我们定义了worker
函数,该函数接收一个WaitGroup参数,执行相应的任务,并在任务执行完成后通过Done
方法通知WaitGroup。在主函数中,我们创建了一个WaitGroup变量,并通过Add
方法指定需要等待的Goroutine数量。然后,使用go
关键字启动相应数量的Goroutine,并将WaitGroup指针传递给每个Goroutine。最后,通过Wait
In Golang wird die Kommunikation zwischen Goroutinen über Channel abgeschlossen. Channel ist eine typsichere Warteschlange, die zum Übertragen von Daten zwischen Goroutinen verwendet wird. Das Folgende ist ein einfaches Kanalbeispiel:
worker
, die verwendet wird, um die vom Jobkanal übergebenen Zahlen zu empfangen und sie entsprechend zu verarbeiten wird übergeben. Der Ergebniskanal gibt zurück. In der Hauptfunktion haben wir zwei Kanäle erstellt, Jobs und Ergebnisse, und den Jobs-Kanal zur Ausführung an drei Goroutinen übergeben. Senden Sie dann 5 Jobs über die for-Schleife an den Jobs-Kanal und schließen Sie den Kanal. Schließlich wird das Rückgabeergebnis des Ergebniskanals über die for-Schleife empfangen und ausgegeben. 🎜sync
-Paket in Golang stellt den WaitGroup-Typ zur Implementierung dieser Funktion bereit. Das Folgende ist ein Beispiel für die Verwendung von WaitGroup: 🎜🎜rrreee🎜Im obigen Code definieren wir die Funktion worker
, die einen WaitGroup-Parameter empfängt, die entsprechende Aufgabe ausführt und Fertig-Methode benachrichtigt WaitGroup. In der Hauptfunktion erstellen wir eine WaitGroup-Variable und geben über die Methode Add
die Anzahl der Goroutinen an, auf die gewartet werden soll. Verwenden Sie dann das Schlüsselwort go
, um die entsprechende Anzahl von Goroutinen zu starten und den WaitGroup-Zeiger an jede Goroutine zu übergeben. Warten Sie abschließend, bis die gesamte Goroutine-Ausführung über die Methode Wait
abgeschlossen ist. 🎜🎜Zusammenfassung: 🎜Durch die in der Golang-Standardbibliothek bereitgestellten Tools und Methoden für die gleichzeitige Programmierung können wir problemlos Programme mit hoher Parallelität implementieren. In diesem Artikel werden gängige gleichzeitige Programmiertechniken wie Goroutine, Channel und WaitGroup vorgestellt und anhand spezifischer Codebeispiele veranschaulicht. Ich hoffe, dass die Leser durch das Studium dieses Artikels die gleichzeitigen Programmierfähigkeiten in Golang besser beherrschen und die Leistung und Betriebseffizienz des Programms verbessern können. 🎜Das obige ist der detaillierte Inhalt vonLeitfaden zur gleichzeitigen Programmierung: Erkundung der Parallelität in der Golang-Standardbibliothek. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!