无锁并发缓存实现

参考https://book.itsfun.top/gopl-zh/ch9/ch9-07.html

package main
import (
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
    "sync"
    "time"
)
type Memo struct {
    f     Func
    requests chan request
}
type Func func(key string) (interface{}, error)
// 一个结果的值
type result struct {
    value interface{}
    err   error
}
// 一个cache单元
type entry struct {
    res     result
    ready chan struct{} // closed when res is ready
}
// 一个请求
type request struct {
    key string
    res chan result // 用来接收结果
}
// 缓存未命中时，调用费时的F函数
func (e *entry) call (f Func, key string) {
    var res result
    res.value, res.err = f(key)
    e.res = res
    close(e.ready) // 用来表明res中的值已就绪
}
// 将结果返回给请求者
func (e *entry) deliver(resChan chan <- result ) {
    <- e.ready // 当e.ready被close后，这里不会再阻塞
    resChan <- e.res
}
func New(f Func) *Memo {
    memo := &Memo{f: f, requests: make(chan request)}
    go memo.serve()
    return memo
}
// 一直接收request请求，并依据cache进行返回
func (memo *Memo) serve() {
    cache := make(map[string]*entry)
    for req := range memo.requests {
        e := cache[req.key]
        if e == nil { // cache未命中
            e = &entry{ready: make(chan struct{})}
            cache[req.key] = e
            go e.call(memo.f, req.key)
        }
        go e.deliver(req.res) // 这里必须用另一个线程去做，保证for循环的流动
    }
}
// Get 读cache
func (memo *Memo) Get(key string) (interface{}, error) {
    resc := make(chan result)
    memo.requests <- request{key: key, res: resc}
    res := <- resc
    return res.value, res.err
}
// 费时的函数
func httpGetBody(url string) (interface{}, error) {
    resp, err := http.Get(url)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    return ioutil.ReadAll(resp.Body)
}
func main() {
    urls := []string{
        "http://www.baidu.com",
        "http://www.163.com",
        "http://www.qq.com",
        "http://www.baidu.com",
        "http://www.baidu.com",
        "http://www.163.com",
        "http://www.qq.com",
        "http://stackoverflow.com",
        "http://stackoverflow.com",
    }
    m := New(httpGetBody)
    var n sync.WaitGroup
    for _, url := range urls {
        n.Add(1)
        go func(url string) {
            start := time.Now()
            value, err := m.Get(url)
            if err != nil {
                log.Print(err)
            }
            fmt.Printf("%s, %s, %d bytes\n",
                url, time.Since(start), len(value.([]byte)))
            n.Done()
        }(url)
    }
    n.Wait()
}