SingleFlight总结
提供了三个参数Do同步通知、Dochan异步chan通知、Forget删除map的存在的键值
每次调用都会重置map
结构体是由mu sync.Mutex、m map[string]*call组成，mu用于操作的排它锁，m用于存储已有的键值的个数
如果m中存在当前键值对，就会阻塞等待，不存在的时候会加创建call结构存入m中
Dochan会异步执行，将结果放入chan通知其他阻塞的协程
阻塞的协程永的WaitGroup实现 

  1. package main
  3. import (
  4.     "time"
  6.     "golang.org/x/sync/singleflight"
  7.     "log"
  8. )
  10. func main() {
  11.     var singleSetCache singleflight.Group
  13.     getAndSetCache := func(requestID int, cacheKey string) (string, error) {
  14.         log.Printf("request %v start to get and set cache...", requestID)
  15.         value, _, _ := singleSetCache.Do(cacheKey, func() (ret interface{}, err error) { //do的入参key，可以直接使用缓存的key，这样同一个缓存，只有一个协程会去读DB
  16.             log.Printf("request %v is setting cache...", requestID)
  17.             time.Sleep(3 * time.Second)
  18.             log.Printf("request %v set cache success!", requestID)
  19.             return "VALUE", nil
  20.         })
  21.         return value.(string), nil
  22.     }
  24.     cacheKey := "cacheKey"
  25.     for i := 1; i < 10; i++ { //模拟多个协程同时请求
  26.         go func(requestID int) {
  27.             value, _ := getAndSetCache(requestID, cacheKey)
  28.             log.Printf("request %v get value: %v", requestID, value)
  29.         }(i)
  30.     }
  31.     time.Sleep(20 * time.Second)
  33.     for i := 1; i < 10; i++ { //模拟多个协程同时请求
  34.         go func(requestID int) {
  35.             value, _ := getAndSetCache(requestID, cacheKey)
  36.             log.Printf("request %v get value: %v", requestID, value)
  37.         }(i)
  38.     }
  40.     time.Sleep(20 * time.Second)
  41. }

每一次调用do都会重新开始，内存不会持久化支持的map集合

docall 的简单使用

  1. package main
  3. import (
  4.     "errors"
  5.     "golang.org/x/sync/singleflight"
  6.     "log"
  7.     "time"
  8. )
  10. func main() {
  11.     var singleSetCache singleflight.Group
  13.     getAndSetCache := func(requestID int, cacheKey string) (string, error) {
  14.         log.Printf("request %v start to get and set cache...", requestID)
  15.         retChan := singleSetCache.DoChan(cacheKey, func() (ret interface{}, err error) {
  16.             log.Printf("request %v is setting cache...", requestID)
  17.             time.Sleep(3 * time.Second)
  18.             log.Printf("request %v set cache success!", requestID)
  19.             return "VALUE", nil
  20.         })
  22.         var ret singleflight.Result
  24.         timeout := time.After(5 * time.Second)
  26.         select { //加入了超时机制
  27.         case <-timeout:
  28.             log.Printf("time out!")
  29.             return "", errors.New("time out")
  30.         case ret = <-retChan: //从chan中取出结果
  31.             return ret.Val.(string), ret.Err
  32.         }
  33.         return "", nil
  34.     }
  36.     cacheKey := "cacheKey"
  37.     for i := 1; i < 10; i++ {
  38.         go func(requestID int) {
  39.             value, _ := getAndSetCache(requestID, cacheKey)
  40.             log.Printf("request %v get value: %v", requestID, value)
  41.         }(i)
  42.     }
  43.     time.Sleep(20 * time.Second)
  44. }
  1. 每一次调用dochan都会重新开始，内存不会持久化支持的map集合,只不过将结果挡在chan中进行传输