如何在不使用sync.WaitGroup的情況下防止死鎖？

Question

concurrent.go：

package main 

import (
    "fmt" 
    "sync" 
) 

// JOBS represents the number of jobs workers do 
const JOBS = 2 

// WORKERS represents the number of workers 
const WORKERS = 5 

func work(in <-chan int, out chan<- int, wg *sync.WaitGroup) { 
    for n := range in { 
     out <- n * n 
    } 
    wg.Done() 
} 

var wg sync.WaitGroup 

func main() { 
    in := make(chan int, JOBS) 
    out := make(chan int, JOBS) 

    for w := 1; w <= WORKERS; w++ { 
     wg.Add(1) 
     go work(in, out, &wg) 
    } 

    for j := 1; j <= JOBS; j++ { 
     in <- j 
    } 
    close(in) 

    wg.Wait() 
    close(out) 
    for r := range out { 
     fmt.Println("result:", r) 
    } 

    // This is a solution but I want to do it with `range out` 
    // and also without WaitGroups 
    // for r := 1; r <= JOBS; r++ { 
    // fmt.Println("result:", <-out) 
    // } 
} 

實施例是here上goplay。

Answer 1

這是在沒有waitgroup的情況下同步的示例的證明。

Example in the Go playground

package main 

import (
    "fmt" 
) 

// number of jobs workers do 
const JOBS = 10 

// number of workers 
const WORKERS = 2 

func work(in <-chan int, out chan<- int, done chan<- bool) { 
    for n := range in { 
     out <- n * n 
    } 
    done <- true 
} 

func main() { 
    in := make(chan int, JOBS) 
    out := make(chan int, JOBS) 
    done := make(chan bool, WORKERS) 

    // launch workers 
    for w := 1; w <= WORKERS; w++ { 
     go work(in, out, done) 
    } 

    // give jobs to workers 
    for j := 1; j <= JOBS; j++ { 
     in <- j 
    } 
    close(in) 

    // list the results 
    go func() { 
     i := 0 
     for r := range out { 
      fmt.Println("result:", r) 

      // when all jobs completed mark as done 
      i++ 
      if i == JOBS { 
       done <- true 
      } 
     } 
    }() 

    // wait for all goroutines to keep up 
    // WORKERS + RESULT go routines 
    for i := 0; i < WORKERS + 1; i++ { 
     <- done 
    } 

    // prevent leaking chans 
    close(out) 
} 

Answer 2

Goroutines同時獨立運行。 Spec: Go statements:

A「走出去」的語句開頭的函數調用的控制，或夠程的獨立併發線程的執行，同樣的地址空間內。

如果你想使用for range從out通道接收值，這意味着out通道只能關閉一次全部夠程完成後發送就可以了。

由於goroutines同時獨立運行，沒有同步，你不能擁有這個。

使用WaitGroup是一個意思，一種方法（確保我們在關閉out之前等待所有goroutines完成工作）。

您的註釋代碼是另一種方式：註釋代碼從通道接收的許多值與許多應用程序應該發送的值一樣多，這隻有在所有的goroutine都發送它們的值時纔有可能。同步是發送語句和接收操作。

注：

從信道一般接收結果異步地完成的，在專用的goroutine，或使用甚至多個夠程。這樣做不需要使用緩衝區能夠緩衝所有結果的通道。您仍需要同步才能等待所有工作人員完成工作，但由於gorutine調度和執行的並行和獨立性質，您無法避免這種情況。