如何在不使用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调度和执行的并行和独立性质，您无法避免这种情况。