Que sont les WaitGroups en langage Go ? Comment utiliser ?

Que sont les WaitGroups ? L'article suivant vous amènera à comprendre WaitGroups dans le langage go et à vous présenter comment utiliser WaitGroups. J'espère qu'il vous sera utile !

Que sont les WaitGroups ?

WaitGroups est un moyen efficace de synchroniser vos goroutines. Imaginez que vous voyagez en voiture avec votre famille. Votre père s'arrête dans un centre commercial ou un fast-food pour acheter de la nourriture et utiliser les toilettes. Vous feriez mieux d'attendre que tout le monde revienne avant de vous rendre à Horizon. WaitGroups vous aide à le faire. 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 est défini en appelant le package sync dans la bibliothèque standard. 🎜rrreee🎜Alors, qu'est-ce que WaitGroup ? WaitGroup est une structure qui contient certaines informations sur le nombre de goroutines que le programme doit attendre. C'est un groupe contenant le nombre de goroutines que vous devez attendre. 🎜🎜WaitGroups a trois méthodes les plus importantes : Add, Done et Wait. 🎜

• Ajouter : ajoutez au nombre total de goroutines que vous devez attendre.
• Terminé : soustrayez une du nombre total de goroutines que vous devez attendre.
• Attendre : empêche le code de continuer jusqu'à ce qu'il n'y ait plus de goroutines à attendre.

🎜🎜Comment utiliser WaitGroups🎜🎜🎜Jetons un coup d'œil à un morceau de code : 🎜rrreeerrreee

• Nous initialisons d'abord une instance de WaitGroup wg .
• Ensuite, nous ajoutons 1 à wg car nous devons attendre qu'une goroutine se termine.
• Ensuite, nous exécutons cette goroutine. À l'intérieur d'une goroutine, nous effectuons un appel retardé à wg.Done() pour nous assurer que nous décrémentons le nombre de goroutines à attendre. Si nous ne le faisons pas, alors le code attendra indéfiniment la fin de la goroutine et provoquera un blocage.
• Après l'appel goroutine, nous devons nous assurer de bloquer le code jusqu'à ce que le WaitGroup soit vide. Nous faisons cela en appelant wg.Wait().

🎜🎜Pourquoi utiliser des WaitGroups au lieu de canaux ? 🎜🎜🎜Maintenant que nous savons utiliser les WaitGroups, une réflexion naturelle nous amène à cette question : pourquoi utiliser les WaitGroups au lieu des canaux ? 🎜🎜D'après mon expérience, il y a plusieurs raisons. 🎜

• WaitGroups a tendance à être plus intuitif. Lorsque vous lisez un morceau de code, lorsque vous voyez un WaitGroup, vous savez immédiatement ce que fait le code. Les noms des méthodes sont clairs et vont droit au but. Cependant, avec les chaînes, ce n'est parfois pas si clair. Utiliser des canaux est intelligent, mais lorsque vous lisez un morceau de code complexe, cela peut être difficile à comprendre.
• Parfois, vous n'avez pas besoin d'utiliser des chaînes. Par exemple, regardons ce code :

rrreee🎜Vous pouvez voir que cette goroutine ne communique pas avec les autres goroutine. Si votre goroutine est un travail ponctuel et que vous n'avez pas besoin de connaître le résultat, il est préférable d'utiliser WaitGroup. Maintenant, regardez ce code : 🎜rrreee🎜Ici, goroutine envoie des données au canal. Dans ces cas, nous n'avons pas besoin d'utiliser WaitGroup car cela serait redondant. Si la réception a déjà effectué suffisamment de blocage, pourquoi attendre que la goroutine se termine ? 🎜🎜WaitGroups est spécialement utilisé pour gérer l'attente des goroutines. Je pense que le but principal des canaux est de communiquer des données. Vous ne pouvez pas utiliser WaitGroup pour envoyer et recevoir des données, mais vous pouvez utiliser un canal pour synchroniser vos goroutines. 🎜🎜En fin de compte, il n’y a pas de bonne réponse. Je sais que cela peut être ennuyeux, mais cela dépend de vous et de l'équipe pour laquelle vous travaillez. Quelle que soit la meilleure méthode, aucune réponse n’est fausse. Personnellement, je préfère utiliser WaitGroups pour la synchronisation, mais votre situation peut être différente. Choisissez ce qui vous semble le plus intuitif. 🎜🎜🎜Une chose à noter🎜🎜🎜Parfois, vous devrez peut-être transmettre une instance de WaitGroup à un goroutine. Il peut y avoir plusieurs WaitGroup pour gérer différents goroutines, ou cela peut être un choix de conception. Quelle que soit la raison, assurez-vous de passer un pointeur vers WaitGroup, comme ceci : 🎜rrreee🎜La raison est que Go est un langage de transmission de valeurs. Cela signifie que chaque fois que vous transmettez un argument à une fonction, Go copie l'argument et le transmet à la place de l'objet d'origine. Ce qui se passe dans ce cas, c'est que l'intégralité de l'objet WaitGroup sera copié, ce qui signifie que le goroutine gérera un WaitGroup complètement différent. wg.Done() ne soustrait pas du wg original, mais en soustrait une copie, qui n'existe que dans goroutine. 🎜

Résumé

En utilisant des pointeurs WaitGroups，我们可以轻松同步goroutines，从而确保我们的代码在正确的时间执行。尽管通道也可以用于同步，但WaitGroups通常更直观且更易于阅读。在使用WaitGroup时，请确保正确传递指向WaitGroup pour éviter les problèmes de copie. Quelle que soit la méthode que vous choisissez, choisissez celle qui est la plus intuitive et qui fonctionne le mieux pour vous et votre équipe.

Apprentissage recommandé : Tutoriel Golang

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!