golang使用sync.singleflight解决热点缓存穿透问题

package main
import (
   "context"
   "fmt"
   "golang.org/x/sync/singleflight"
   "sync/atomic"
   "time"
   )
type Result string
// 模拟查询数据库
func find(ctx context.Context, query string) (Result, error) {
   return Result(fmt.Sprintf("result for %q", query)), nil
}
func main() {
   var g singleflight.Group
   const n = 200
   waited := int32(n)
   done := make(chan struct{})
   key := "this is key"
   for i := 0; i < n; i++ {
      go func(j int) {
         v, _, shared := g.Do(key, func() (interface{}, error) {
            ret, err := find(context.Background(), key)
            return ret, err
         })
         if atomic.AddInt32(&waited, -1) == 0 {
            close(done)
         }
         fmt.Printf("index: %d, val: %v, shared: %v\n", j, v, shared)
      }(i)
   }
   select {
   case <-done:
   case <-time.After(time.Second):
      fmt.Println("Do hangs")
   }
   time.Sleep(time.Second * 4)
}

ch := g.DoChan(key, func() (interface{}, error) {
   ret, err := find(context.Background(), key)
   return ret, err
})
// Create our timeout
timeout := time.After(500 * time.Millisecond)
var ret singleflight.Result
select {
case <-timeout: // Timeout elapsed
   fmt.Println("Timeout")
   return
case ret = <-ch: // Received result from channel
   fmt.Printf("index: %d, val: %v, shared: %v\n", j, ret.Val, ret.Shared)
}

ch := g.DoChan(key, func() (interface{}, error) {
   go func() {
      time.Sleep(10 * time.Millisecond)
      fmt.Printf("Deleting key: %v\n", key)
      g.Forget(key)
   }()
   ret, err := find(context.Background(), key)
   return ret, err
})