Пример для sync.WaitGroup правильно?

Правильно ли этот пример использования sync.WaitGroup? Это дает ожидаемый результат, но я не уверен насчет положения wg.Add(4)и wg.Done(). Имеет ли смысл добавлять сразу четыре горутины wg.Add()?

http://play.golang.org/p/ecvYHiie0P

package main

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

func dosomething(millisecs time.Duration, wg *sync.WaitGroup) {
    duration := millisecs * time.Millisecond
    time.Sleep(duration)
    fmt.Println("Function in background, duration:", duration)
    wg.Done()
}

func main() {
    var wg sync.WaitGroup
    wg.Add(4)
    go dosomething(200, &wg)
    go dosomething(400, &wg)
    go dosomething(150, &wg)
    go dosomething(600, &wg)

    wg.Wait()
    fmt.Println("Done")
}

Результат (как и ожидалось):

Function in background, duration: 150ms
Function in background, duration: 200ms
Function in background, duration: 400ms
Function in background, duration: 600ms
Done

Да, этот пример верен. Важно, чтобы это произошло wg.Add()перед goоператором, чтобы предотвратить состояние гонки. Также будет правильным следующее:

func main() {
    var wg sync.WaitGroup
    wg.Add(1)
    go dosomething(200, &wg)
    wg.Add(1)
    go dosomething(400, &wg)
    wg.Add(1)
    go dosomething(150, &wg)
    wg.Add(1)
    go dosomething(600, &wg)

    wg.Wait()
    fmt.Println("Done")
}

Однако звонить wg.Addснова и снова, когда вы уже знаете, сколько раз он будет вызван, довольно бессмысленно .

Waitgroupsпаника, если счетчик упадет ниже нуля. Счетчик начинается с нуля, каждый Done()равен a, -1и каждый Add()зависит от параметра. Итак, чтобы счетчик никогда не опускался ниже, и чтобы избежать паники, вам нужно, Add()чтобы он гарантированно пришел раньше Done().

В Go такие гарантии дает модель памяти .

Модель памяти утверждает, что все операторы в одной горутине выполняются в том же порядке, в котором они написаны. Возможно, они на самом деле не будут в таком порядке, но результат будет таким, как если бы он был. Также гарантируется, что горутина не запустится до тех пор, пока не будет вызвана goинструкция, которая ее вызывает . Поскольку оператор Add()встречается перед goоператором, а goоператор - перед оператором Done(), мы знаем, что это Add()происходит перед оператором Done().

Если вы поставили этот goоператор перед Add(), программа может работать правильно. Однако это будет состояние гонки, потому что это не будет гарантировано.

Я бы порекомендовал встроить wg.Add()вызов в doSomething()саму функцию, чтобы, если вы измените количество раз, которое он вызывается , вам не нужно отдельно настраивать параметр добавления вручную, что может привести к ошибке, если вы обновите один, но забудете обновить другое (в этом тривиальном примере это маловероятно, но все же я лично считаю, что это лучшая практика для повторного использования кода).

Как указывает Стивен Вайнберг в своем ответе на этот вопрос , вам нужно увеличить группу ожидания до создания gofunc, но вы можете легко добиться этого, заключив порождение gofunc внутри самой doSomething()функции, например:

func dosomething(millisecs time.Duration, wg *sync.WaitGroup) {
    wg.Add(1)
    go func() {
        duration := millisecs * time.Millisecond
        time.Sleep(duration)
        fmt.Println("Function in background, duration:", duration)
        wg.Done()
    }()
}

Затем вы можете вызвать его без goвызова, например:

func main() {
    var wg sync.WaitGroup
    dosomething(200, &wg)
    dosomething(400, &wg)
    dosomething(150, &wg)
    dosomething(600, &wg)
    wg.Wait()
    fmt.Println("Done")
}

В качестве игровой площадки: http://play.golang.org/p/WZcprjpHa_

• небольшое улучшение, основанное на ответе Мрота
• использование defer for Done безопаснее

  func dosomething(millisecs time.Duration, wg *sync.WaitGroup) {
  wg.Add(1)
  go func() {
      defer wg.Done()
      duration := millisecs * time.Millisecond
      time.Sleep(duration)
      fmt.Println("Function in background, duration:", duration)
  }()
}

func main() {
  var wg sync.WaitGroup
  dosomething(200, &wg)
  dosomething(400, &wg)
  dosomething(150, &wg)
  dosomething(600, &wg)
  wg.Wait()
  fmt.Println("Done")
}