解决代码中的死锁问题并实现无缓冲通道上的阻塞等待

最近发现不少小伙伴都对golang很感兴趣，所以今天继续给大家介绍Golang相关的知识，本文《解决代码中的死锁问题并实现无缓冲通道上的阻塞等待》主要内容涉及到等等知识点，希望能帮到你！当然如果阅读本文时存在不同想法，可以在评论中表达，但是请勿使用过激的措辞~

我正在尝试学习 go 中的通道，因此这是一个人为的示例，其中有一个通道，其中有多个作者，但只有一个读者。这是一个非常基本的示例，但我想更进一步，想象它是一个 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 服务器发出请求）？

解决方案

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

1. 由于您想使用 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()
}

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
        }
    }
}

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)