如何修复此代码中的死锁，并扩展它以便它可以在没有编写器的通道上等待？

Question

我正在尝试学习 Go 中的频道，所以这是一个人为的示例，其中有一个频道，其中有多个作者，但只有一个 reader。这是一个非常基本的例子，但我想更进一步，想象它是一个 http 服务器，其中为每个新请求创建一个 goroutine，每个 goroutine 在一个通道上进行写入。

func Start2(){
    var wg sync.WaitGroup
    wg.Add(2)
    c := make(chan int)
    go func(){
        defer wg.Done()
        i := 0
        for {
            
            i+=2
            c<-i
            time.Sleep(time.Duration(rand.Intn(5)) * time.Second)
            if i > 10 {
                break
            }
        }
    }()

    go func(){
        defer wg.Done()
        i := 1
        for {
            i+=2
            c<-i
            time.Sleep(time.Duration(rand.Intn(5)) * time.Second)
            if i > 10 {
                break
            }
        }
    }()
    

    for a := range c {
        log.Println(a)
    }

    wg.Wait()
    
}

为什么会出现这种僵局？我如何组织从通道读取的逻辑，以便在通道上没有编写器时代码不会死锁？（例如，在最终目标示例中，如果当前没有向 http 服务器发出请求）?

Answer 1

您没有关闭频道，完成后需要关闭它。

您可以创建一个 goroutine 来从您的频道读取并在等待组之后关闭它。

示例：

var wg sync.WaitGroup
wg.Add(2)
c := make(chan int)
go func() {
    defer wg.Done()
    i := 0
    for {

        i += 2
        c <- i
        time.Sleep(time.Duration(rand.Intn(5)) * time.Second)
        if i > 10 {
            return
        }
    }
}()

go func() {
    defer wg.Done()
    i := 1
    for {
        i += 2
        c <- i
        time.Sleep(time.Duration(rand.Intn(5)) * time.Second)
        if i > 10 {
            break
        }
    }
}()
//read channel in a goroutine
go func() {
    for a := range c {
        log.Println(a)
    }
}()

wg.Wait()
//close channel when done
close(c)

Answer 2

无缓冲通道至少需要 两个 goroutines 才能运行并退出其中之一。 Go 运行时足够智能，可以检测死锁，因此您在这里有两个选择：

由于您想使用 http 服务器中的通道 - 这里没有死锁：

package main

import (
    "fmt"
    "log"
    "net/http"
    "time"
)

func main() {
    http.HandleFunc("/", home)
    go func() {
        err := http.ListenAndServe(":8080", nil)
        if err != nil {
            log.Fatal(err)
        }
    }()
    count := 0
    for a := range c {
        count++
        fmt.Println(count, a)
    }
}

var c = make(chan time.Time)

func home(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Hi")
    c <- time.Now()
}

或者关闭通道以强制主 goroutine 也退出 - 仅针对您当前的示例代码 - try it:

package main

import (
    "log"
    "math/rand"
    "sync"
    "time"
)

func main() {
    wg := &sync.WaitGroup{}
    wg.Add(2)
    c := make(chan int)
    go routine(0, c, wg)
    go routine(1, c, wg)
    go func() {
        wg.Wait()
        close(c)
    }()

    for a := range c {
        log.Println(a)
    }
}

func routine(i int, c chan int, wg *sync.WaitGroup) {
    defer wg.Done()
    for {
        i += 2
        c <- i
        time.Sleep(time.Duration(rand.Intn(5)) * time.Second)
        if i > 10 {
            break
        }
    }
}

如何修复此代码中的死锁，并扩展它以便它可以在没有编写器的通道上等待？

How to fix the deadlock in this code, and extend it so that it can wait on a channel which has no writers?

go

channel