Was sind WaitGroups in der Go-Sprache? Wie benutzt man?

Was sind WaitGroups? Der folgende Artikel wird Ihnen helfen, WaitGroups in der Go-Sprache zu verstehen und Ihnen die Verwendung von WaitGroups vorzustellen. Ich hoffe, er wird Ihnen hilfreich sein!

Was sind WaitGroups?

WaitGroups ist eine effiziente Möglichkeit, Ihre Goroutinen zu synchronisieren. Stellen Sie sich vor, Sie reisen mit Ihrer Familie mit dem Auto. Dein Vater hält in einem Einkaufszentrum oder Fast-Food-Restaurant an, um etwas zu essen zu kaufen und auf die Toilette zu gehen. Warten Sie lieber, bis alle zurück sind, bevor Sie nach Horizon fahren. WaitGroups hilft Ihnen dabei. WaitGroups是同步你的goroutines的一种有效方式。想象一下，你和你的家人一起驾车旅行。你的父亲在一个条形商场或快餐店停下来，买些食物和上厕所。你最好想等大家回来后再开车去地平线。WaitGroups帮助你做到这一点。

WaitGroups是通过调用标准库中的sync包来定义的。

var wg sync.WaitGroup

那么，什么是WaitGroup呢？WaitGroup是一个结构，它包含了程序需要等待多少个goroutine的某些信息。它是一个包含你需要等待的goroutines数量的组。

WaitGroups有三个最重要的方法: Add, Done和 Wait。

• Add: 添加到你需要等待的goroutines的总量上。
• Done: 从你需要等待的goroutines总数中减去一个。
• Wait: 阻止代码继续进行，直到没有更多的goroutines需要等待。

如何使用WaitGroups

让我们来看看一段代码：

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var wg sync.WaitGroup
    wg.Add(1)

    go func() {
        defer wg.Done()

        fmt.Println(time.Now(), "start")
        time.Sleep(time.Second)
        fmt.Println(time.Now(), "done")
    }()

    wg.Wait()
    fmt.Println(time.Now(), "exiting...")
}

2022-08-21 17:01:54.184744229 +0900 KST m=+0.000021800 start
2022-08-21 17:01:55.184932851 +0900 KST m=+1.000210473 done
2022-08-21 17:01:55.18507731 +0900 KST m=+1.000354912 exiting...

• 我们首先初始化一个WaitGroup wg的实例。
• 然后我们在wg中添加1，因为我们要等待一个goroutine完成。
• 然后我们运行这个goroutine。在goroutine内部，我们对wg.Done()进行延迟调用，以确保我们递减要等待的goroutine的数量。如果我们不这样做，那么代码将永远等待goroutine完成，并将导致死锁。
• 在goroutine调用之后，我们要确保阻断代码，直到WaitGroup为空。我们通过调用wg.Wait()来做到这一点。

为什么使用WaitGroups而不是channel？

现在我们知道了如何使用WaitGroups，一个自然而然的想法将我们引向这个问题：为什么使用WaitGroups而不是通道？

根据我的经验，有几个原因。

• WaitGroups往往更直观。当你阅读一段代码时，当你看到一个WaitGroup时，你会立即知道代码在做什么。方法的名称很明确，而且直奔主题。然而，对于通道来说，有时就不是那么清楚了。使用通道是很聪明的，但当你阅读一段复杂的代码时，理解起来会很麻烦。
• 有的时候，你不需要使用通道。例如，让我们看一下这段代码：

 var wg sync.WaitGroup

  for i := 0; i < 5; i++ {
      wg.Add(1)
      go func() {
          defer wg.Done()

          fmt.Println(time.Now(), "start")
          time.Sleep(time.Second)
          fmt.Println(time.Now(), "done")
      }()
  }

  wg.Wait()
  fmt.Println(time.Now(), "exiting...")

你可以看到，这个goroutine并没有与其他goroutine进行数据交流。如果你的goroutine是一次性的工作，你不需要知道结果，使用WaitGroup是可取的。现在看一下这段代码：

  ch := make(chan int)

  for i := 0; i < 5; i++ {
      go func() {
          randomInt := rand.Intn(10)
          ch <- randomInt
      }()
  }

  for i := 0; i < 5; i++ {
      fmt.Println(<-ch)
  }

这里，goroutine正在向 channel 发送数据。在这些情况下，我们不需要使用WaitGroup，因为这将是多余的。如果接收已经做了足够的阻塞，为什么还要等待goroutine完成？

WaitGroups是专门用来处理等待goroutines的。我觉得通道的主要目的是为了交流数据。你不能用WaitGroup来发送和接收数据，但你可以用一个channel来同步你的goroutines。

最后，没有正确的答案。我知道这可能很烦人，但这取决于你和你工作的团队。无论什么方法都是最好的，没有答案是错误的。我个人倾向于使用WaitGroups进行同步，但你的情况可能有所不同。选择对你来说最直观的东西。

需要注意的一件事

有时，你可能需要将WaitGroup实例传递给goroutine。可能有几个WaitGroup来处理不同的goroutine，也可能是一种设计选择。不管是什么原因，请确保传递指向WaitGroup的指针，像这样：

var wg sync.WaitGroup

for i := 0; i < 5; i++ {
    wg.Add(1)
    go func(wg *sync.WaitGroup) {
        defer wg.Done()

        fmt.Println(time.Now(), "start")
        time.Sleep(time.Second)
        fmt.Println(time.Now(), "done")
    }(&wg)
}

wg.Wait()
fmt.Println(time.Now(), "exiting...")

原因是Go是一种值传递的语言。这意味着每当你向一个函数传递一个参数时，Go会复制一个参数并传递给它而不是原始对象。在这种情况下发生的是，整个WaitGroup对象将被复制，这意味着goroutine将处理一个完全不同的WaitGroup。wg.Done()不会从原始的wg中减去，而是减去它的一个副本，这个副本只存在于goroutine

WaitGroups wird durch Aufrufen des sync-Pakets in der Standardbibliothek definiert. 🎜rrreee🎜Also, was ist WaitGroup? WaitGroup ist eine Struktur, die bestimmte Informationen darüber enthält, auf wie viele Goroutinen das Programm warten muss. Es handelt sich um eine Gruppe, die die Anzahl der goroutines enthält, auf die Sie warten müssen. 🎜🎜WaitGroups verfügt über drei wichtigste Methoden: Add, Done und Wait. 🎜

• Hinzufügen: Zur Gesamtzahl der Goroutinen hinzufügen, auf die Sie warten müssen.
• Fertig: Subtrahieren Sie eins von der Gesamtzahl der Goroutinen, auf die Sie warten müssen.
• Warten: Verhindert, dass der Code fortgesetzt wird, bis keine weiteren Goroutinen mehr warten.

🎜🎜So verwenden Sie WaitGroups🎜🎜🎜Werfen wir einen Blick auf ein Stück Code: 🎜rrreeerrreee

• Wir initialisieren zunächst eine Instanz von WaitGroup wg .
• Dann fügen wir 1 zu wg hinzu, weil wir warten müssen, bis eine goroutine abgeschlossen ist.
• Dann führen wir diese goroutine aus. Innerhalb einer goroutine führen wir einen verzögerten Aufruf von wg.Done() durch, um sicherzustellen, dass wir die Anzahl der zu wartenden goroutines verringern. Wenn wir dies nicht tun, wartet der Code ewig auf den Abschluss der goroutine und verursacht einen Deadlock.
• Nach dem goroutine-Aufruf müssen wir sicherstellen, dass der Code blockiert wird, bis die WaitGroup leer ist. Wir tun dies, indem wir wg.Wait() aufrufen.

🎜🎜Warum WaitGroups anstelle von Kanälen verwenden? 🎜🎜🎜Da wir nun wissen, wie man WaitGroups verwendet, führt uns ein natürlicher Gedanke zu dieser Frage: Warum WaitGroups anstelle von Kanälen verwenden? 🎜🎜Meiner Erfahrung nach gibt es dafür mehrere Gründe. 🎜

• WaitGroups ist tendenziell intuitiver. Wenn Sie einen Codeabschnitt lesen und eine WaitGroup sehen, wissen Sie sofort, was der Code tut. Die Methodennamen sind klar und bringen es auf den Punkt. Bei Kanälen ist es jedoch manchmal nicht so klar. Die Verwendung von Kanälen ist intelligent, aber wenn Sie einen komplexen Code lesen, kann es schwierig sein, ihn zu verstehen.
• Manchmal müssen Sie keine Kanäle verwenden. Schauen wir uns zum Beispiel diesen Code an:

rrreee🎜Sie können sehen, dass diese goroutine nicht mit anderen goroutine kommuniziert. Wenn Ihre goroutine ein einmaliger Job ist und Sie das Ergebnis nicht kennen müssen, ist die Verwendung von WaitGroup vorzuziehen. Schauen Sie sich nun diesen Code an: 🎜rrreee🎜Hier sendet goroutine Daten an channel. In diesen Fällen müssen wir WaitGroup nicht verwenden, da dies überflüssig wäre. Wenn der Empfang bereits ausreichend blockiert hat, warum dann warten, bis die goroutine abgeschlossen ist? 🎜🎜WaitGroups wird speziell zum Warten auf Goroutinen verwendet. Ich denke, der Hauptzweck von Kanälen besteht darin, Daten zu kommunizieren. Sie können WaitGroup nicht zum Senden und Empfangen von Daten verwenden, aber Sie können einen Kanal verwenden, um Ihre Goroutinen zu synchronisieren. 🎜🎜Am Ende gibt es keine richtige Antwort. Ich weiß, dass das ärgerlich sein kann, aber es hängt von Ihnen und dem Team ab, für das Sie arbeiten. Welche Methode auch immer die beste ist, keine Antwort ist falsch. Ich persönlich bevorzuge die Verwendung von WaitGroups für die Synchronisierung, aber Ihre Situation kann anders sein. Wählen Sie, was sich für Sie am intuitivsten anfühlt. 🎜🎜🎜Eines ist zu beachten🎜🎜🎜Manchmal müssen Sie möglicherweise eine WaitGroup-Instanz an eine goroutine übergeben. Möglicherweise gibt es mehrere WaitGroups, um unterschiedliche Goroutinen zu verarbeiten, oder es kann eine Entwurfsentscheidung sein. Was auch immer der Grund sein mag, stellen Sie sicher, dass Sie einen Zeiger an WaitGroup übergeben, etwa so: 🎜rrreee🎜Der Grund dafür ist, dass Go eine Sprache mit Wertübergabe ist. Das bedeutet, dass Go jedes Mal, wenn Sie ein Argument an eine Funktion übergeben, das Argument kopiert und es anstelle des ursprünglichen Objekts übergibt. In diesem Fall wird das gesamte WaitGroup-Objekt kopiert, was bedeutet, dass die goroutine eine völlig andere WaitGroup verarbeitet. wg.Done() subtrahiert nicht vom ursprünglichen WG, sondern subtrahiert eine Kopie davon, die nur in goroutine existiert. 🎜

Zusammenfassung

Durch die Verwendung von WaitGroups，我们可以轻松同步goroutines，从而确保我们的代码在正确的时间执行。尽管通道也可以用于同步，但WaitGroups通常更直观且更易于阅读。在使用WaitGroup时，请确保正确传递指向WaitGroup-Zeigern zur Vermeidung von Kopierproblemen. Egal für welche Methode Sie sich entscheiden, wählen Sie diejenige, die am intuitivsten ist und für Sie und Ihr Team am besten funktioniert.

Empfohlenes Lernen: Golang-Tutorial

Das obige ist der detaillierte Inhalt vonWas sind WaitGroups in der Go-Sprache? Wie benutzt man?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!