令人惊讶的频道现身

编程并不是一个机械性的工作，而是需要有思考，有创新的工作，语法是固定的，但解决问题的思路则是依靠人的思维，这就需要我们坚持学习和更新自己的知识。今天golang学习网就整理分享《令人惊讶的频道现身》，文章讲解的知识点主要包括，如果你对Golang方面的知识点感兴趣，就不要错过golang学习网，在这可以对大家的知识积累有所帮助，助力开发能力的提升。

在下面的 go func(cachech, dbch <- chan book) 中，我不明白为什么需要 <-dbch ..有人可以解释一下吗？ 我遇到了截止日期问题，没有，我无法解释这是如何解决这个问题的。 看起来好像是说 dbch 应该发送回来，但不确定它是什么、它要去哪里以及它如何帮助解决死锁。

__ 有问题的代码 __

go func(cachech, dbch <- chan book) {
        select {
            case b := <-cachech:
                fmt.println("from cache")
                fmt.println(b)
                <-dbch
            case b := <-dbch:
                fmt.println("from database")
                fmt.println(b)

__ 整个代码 __ 包主要

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

var cache = map[int]Book{}
var rnd = rand.New(rand.NewSource(time.Now().UnixNano()))

func main() {
    wg := &sync.WaitGroup{}
    mt := &sync.RWMutex{}
    cacheCh := make(chan Book)
    dbCh := make(chan Book)

    for i:=0; i<10; i++ {
        id := rnd.Intn(10)+1
        wg.Add(2)
        go func(id int, wg *sync.WaitGroup, mt *sync.RWMutex, ch chan<- Book) {
            if b,ok := queryCache(id,mt); ok {
                //fmt.Println("from cache")
                //fmt.Println(b)
                ch <- b
            }
            wg.Done()
        }(id,wg,mt,cacheCh)

        go func(id int, wg *sync.WaitGroup, mt *sync.RWMutex,ch chan<- Book) {
            if b,ok := queryDatabase(id,mt); ok {
                //fmt.Println("from database")
                //fmt.Println(b)
                ch <- b
            }
            wg.Done()
        }(id,wg,mt,dbCh)


        go func(cacheCh, dbCh <- chan Book) {
            select {
                case b := <-cacheCh:
                    fmt.Println("from cache")
                    fmt.Println(b)
                    <-dbCh
                case b := <-dbCh:
                    fmt.Println("from database")
                    fmt.Println(b)

            }
        }(cacheCh,dbCh)

        //fmt.Printf("Book not found with id: %v\n", id)
        //time.Sleep(550 * time.Millisecond)
        wg.Wait()
    }
}

func queryCache(id int, mt *sync.RWMutex) (Book, bool ) {
    mt.RLock()
    b, ok := cache[id]
    mt.RUnlock()
    return b,ok
}

func queryDatabase(id int, mt *sync.RWMutex) (Book, bool) {
    for _, b := range books {
        if b.ID == id {
            mt.Lock()
            cache[id] = b
            mt.Unlock()
            return b, true
        }
    }

    return Book{}, false
}

解决方案

让我们考虑一下 main 每次循环时正在做什么（没有 <-dbch）：

wg.Add(2)
go func(id int, wg *sync.WaitGroup, mt *sync.RWMutex, ch chan<- Book) {
    // IF in cache then send book to cacheCh (will block if nothing receiving on cacheCh)
    wg.Done()
}(id, wg, mt, cacheCh)

go func(id int, wg *sync.WaitGroup, mt *sync.RWMutex, ch chan<- Book) {
    // IF in data base then send book to dbCh (will block if nothing receiving on dbCh)
    wg.Done()
}(id, wg, mt, dbCh)

go func(cacheCh, dbCh <-chan Book) {
    // RECEIVE ONE book from EITHER cacheCh or dbCh and process it 
}(cacheCh, dbCh)
wg.Wait()

因此每次迭代都可能发生以下三种情况之一：

1. 这本书不在数据库或缓存中，因此不会将任何内容写入通道。在这种情况下，程序将继续（随着时间的推移，这可能会成为一个问题，因为您最终会运行额外的 go 例程，等待来自某个通道的数据）。
2. 数据库返回一个不在缓存中的值。这可以;等待数据的 go 例程将收到该值，一切都很好。
3. 数据库和缓存都会返回一个值。

问题是情况 3。等待数据的 go 例程一旦从两个通道之一接收到数据就退出。假设第一个值来自缓存，这意味着 dbch 未清空。

在循环的下一次迭代中，select 将立即从 dbch 获取值，这意味着发送到任一通道将被阻塞（来自 the spec：“如果容量为零或不存在，则通道不缓冲，并且只有当两个通道都满足条件时，通信才会成功）发送者和接收者已准备就绪”）。这样做的结果是 wg.done() 将不会被调用，因此 wg.wait() 将不会返回 = 死锁。

添加 <-dbch 是一种基于以下假设的解决方法：如果从缓存收到一个值，那么也会有一个来自数据库的值。

请注意，此代码做出了一些假设，这些假设在实际系统中可能并不总是有效：

1. 它假设永远不会出现缓存中有书但数据库中没有的情况（如果从数据库中删除一本书或数据库出现故障会发生什么？）。
2. 当一本书同时存在于缓存和数据库中时，它假定始终首先接收到来自缓存的值。一般来说，您会期望出现这种情况，但我觉得冒这个险并不安全。

本篇关于《令人惊讶的频道现身》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于Golang的相关知识，请关注golang学习网公众号！