更简的并发代码，更强的并发控制

func (f *AtomicFloat64) Add(val float64) float64 {
 for {
  old := f.Load()
  nv := old + val
  if f.CompareAndSwap(old, nv) {
   return nv
  }
 }
}
func (f *AtomicFloat64) CompareAndSwap(old, val float64) bool {
 return atomic.CompareAndSwapUint64((*uint64)(f), math.Float64bits(old), math.Float64bits(val))
}
func (f *AtomicFloat64) Load() float64 {
 return math.Float64frombits(atomic.LoadUint64((*uint64)(f)))
}
func (f *AtomicFloat64) Set(val float64) {
 atomic.StoreUint64((*uint64)(f), math.Float64bits(val))
}

func (b *Barrier) Guard(fn func()) {
 b.lock.Lock()
 defer b.lock.Unlock()
  // 自己的业务逻辑
 fn()
}

func NewTimeoutLimit(n int) TimeoutLimit {
 return TimeoutLimit{
  limit: NewLimit(n),
  cond:  NewCond(),
 }
}
func NewLimit(n int) Limit {
 return Limit{
  pool: make(chan lang.PlaceholderType, n),
 }
}

func (cs *concurrentSession) takeSession(opts ...Option) (*mgo.Session, error) {
  // 选项参数注入
 ...
  // 看 limit 中是否还能取出资源
 if err := cs.limit.Borrow(o.timeout); err != nil {
  return nil, err
 } else {
  return cs.Copy(), nil
 }
}
func (l TimeoutLimit) Borrow(timeout time.Duration) error {
  // 1. 如果还有 limit 中还有资源，取出一个，返回
 if l.TryBorrow() {
  return nil
 }
 // 2. 如果 limit 中资源已经用完了
 var ok bool
 for {
    // 只有 cond 可以取出一个【无缓存，也只有 cond <- 此条才能通过】
  timeout, ok = l.cond.WaitWithTimeout(timeout)
    // 尝试取出一个【上面 cond 通过时，就有一个资源返回了】
    // 看 `Return()`
  if ok && l.TryBorrow() {
   return nil
  }
  // 超时控制
  if timeout <= 0 {
   return ErrTimeout
  }
 }
}
func (l TimeoutLimit) Return() error {
  // 返回去一个资源
 if err := l.limit.Return(); err != nil {
  return err
 }
 // 同步通知另一个需要资源的协程【实现了阀门，两方交换】
 l.cond.Signal()
 return nil
}

type ManagedResource struct {
  // 资源
 resource interface{}
 lock     sync.RWMutex
  // 生成资源的逻辑，由开发者自己控制
 generate func() interface{}
  // 对比资源
 equals   func(a, b interface{}) bool
}
type ResourceManager struct {
  // 资源：这里看得出来是 I/O，
 resources   map[string]io.Closer
 sharedCalls SharedCalls
  // 对资源map互斥访问
 lock        sync.RWMutex
}

func (manager *ResourceManager) GetResource(key, create func() (io.Closer, error)) (io.Closer, error)
// 获取一个资源（有就直接获取，没有生成一个）
func (mr *ManagedResource) Take() interface{}
// 判断这个资源是否不符合传入的判断要求，不符合则重置
func (mr *ManagedResource) MarkBroken(resource interface{})

func (r *RefResource) Use() error {
  // 互斥访问
 r.lock.Lock()
 defer r.lock.Unlock()
 // 清除标记
 if r.cleaned {
  return ErrUseOfCleaned
 }
 // 引用 +1
 r.ref++
 return nil
}

// 当多个请求同时使用Do方法请求资源时
func (g *sharedGroup) Do(key string, fn func() (interface{}, error)) (interface{}, error) {
  // 先申请加锁
  g.lock.Lock()
  // 根据key，获取对应的call结果,并用变量c保存
  if c, ok := g.calls[key]; ok {
    // 拿到call以后，释放锁，此处call可能还没有实际数据，只是一个空的内存占位
    g.lock.Unlock()
    // 调用wg.Wait，判断是否有其他goroutine正在申请资源，如果阻塞，说明有其他goroutine正在获取资源
    c.wg.Wait()
    // 当wg.Wait不再阻塞，表示资源获取已经结束，可以直接返回结果
    return c.val, c.err
  }
  // 没有拿到结果，则调用makeCall方法去获取资源，注意此处仍然是锁住的，可以保证只有一个goroutine可以调用makecall
  c := g.makeCall(key, fn)
  // 返回调用结果
  return c.val, c.err
}