type Cache struct {
    *cache
    // If this is confusing, see the comment at the bottom of New()
    // 如果這令人困惑，請(qǐng)參閱New()底部的注釋。
}
type cache struct {
    defaultExpiration time.Duration
    items             map[string]Item  //存儲(chǔ)鍵值對(duì)
    mu                sync.RWMutex     // 讀寫鎖，并發(fā)安全
    onEvicted         func(string, interface{})  // 被清除時(shí)的回調(diào)函數(shù)
    janitor           *janitor         // 腳本，定期清理過期數(shù)據(jù)
}
type Item struct {
    Object     interface{} // 存儲(chǔ)的值
    Expiration int64   // 到期時(shí)間
}

// Return a new cache with a given default expiration duration and cleanup interval.
// 返回具有給定默認(rèn)過期和清除時(shí)間的 new cache新緩存
// If the expiration duration is less than one (or NoExpiration),
// the items in the cache never expire (by default), 
// 假如 到期時(shí)間為-1,永不過期
// and must be deleted manually.
// 并且只能手動(dòng)刪除。
// If the cleanup interval is less than one, expired items are not
// 如果清除時(shí)間小于1，過期item，在call之前是沒有被刪除的。
// deleted from the cache before calling c.DeleteExpired().
func New(defaultExpiration, cleanupInterval time.Duration) *Cache {
    items := make(map[string]Item)
    return newCacheWithJanitor(defaultExpiration, cleanupInterval, items)
}
func newCacheWithJanitor(de time.Duration, ci time.Duration, m map[string]Item) *Cache {
    c := newCache(de, m)
    // This trick ensures that the janitor goroutine (which--granted it
    // 這個(gè)代碼，確認(rèn)是否啟動(dòng) janitor看門人goroutine
    // was enabled--is running DeleteExpired on c forever) does not keep
    // the returned C object from being garbage collected. When it is
    // garbage collected, the finalizer stops the janitor goroutine, after
    // which c can be collected.
    C := &Cache{c}
    if ci > 0 {
       runJanitor(c, ci)  // 調(diào)用守衛(wèi)進(jìn)程來清理過期數(shù)據(jù)
       runtime.SetFinalizer(C, stopJanitor)
       // runtime.SetFinalizer(C, stopJanitor)會(huì)指定調(diào)用函數(shù)停止后臺(tái) goroutine，
       // 當(dāng) GC 準(zhǔn)備釋放對(duì)象時(shí)，會(huì)調(diào)用stopJanitor方法，
       // Run函數(shù)中j.stop通道會(huì)輸出一個(gè)信號(hào)，從而退出協(xié)程。
    }
    return C
}
func runJanitor(c *cache, ci time.Duration) {
    j := &janitor{
       Interval: ci,
       stop:     make(chan bool),
    }
    c.janitor = j
    go j.Run(c)   // 調(diào)用守衛(wèi)進(jìn)程來清理過期數(shù)據(jù)
}
// 開啟一個(gè)定時(shí)器，來定時(shí)清理數(shù)據(jù)。
func (j *janitor) Run(c *cache) {
    // 創(chuàng)建了一個(gè)計(jì)時(shí)器,時(shí)間到時(shí)ticker.C通道會(huì)輸出一個(gè)值,調(diào)用DeleteExpired()函數(shù)
    // 該函數(shù)會(huì)通過遍歷cache中的map[string]Item的過期時(shí)間，過期則直接從map中刪除，
    // 如果該值有回調(diào)函數(shù)，則在刪除后執(zhí)行回調(diào)函數(shù)。
    ticker := time.NewTicker(j.Interval)
    for {
       select {
       case <-ticker.C:
          c.DeleteExpired()
       case <-j.stop:
          ticker.Stop()
          return
       }
    }
}
// Delete all expired items from the cache.
// 刪除cache中所有的過期items
// 此時(shí)會(huì)加鎖，如果定時(shí)清理的時(shí)間比較長，并且key比較多的話，
// 會(huì)導(dǎo)致一直被  清理協(xié)程鎖住。其他的協(xié)程沒法寫入。
func (c *cache) DeleteExpired() {
    var evictedItems []keyAndValue
    now := time.Now().UnixNano()
    c.mu.Lock()
    // 過期刪除的時(shí)候，需要上鎖。
    for k, v := range c.items {
       // "Inlining" of expired
       if v.Expiration > 0 && now > v.Expiration {
          ov, evicted := c.delete(k)
          if evicted {
             evictedItems = append(evictedItems, keyAndValue{k, ov})
          }
       }
    }
    c.mu.Unlock()
    // 刪除完解鎖
    for _, v := range evictedItems {
       c.onEvicted(v.key, v.value)
    }
}
func (c *cache) delete(k string) (interface{}, bool) {
    if c.onEvicted != nil {
       if v, found := c.items[k]; found {
          delete(c.items, k)
          return v.Object, true
       }
    }
    delete(c.items, k)
    return nil, false
}

// Get an item from the cache. Returns the item or nil, and a bool indicating
// whether the key was found.
// 從cache中Get一個(gè)item.返回item或者nil，和一個(gè)bool值。
func (c *cache) Get(k string) (interface{}, bool) {
    c.mu.RLock()
    // "Inlining" of get and Expired
    item, found := c.items[k]
    if !found {
       c.mu.RUnlock()
       return nil, false
    }
    // 獲取到item，是否能返回還需要判斷過期時(shí)間
    if item.Expiration > 0 {
       if time.Now().UnixNano() > item.Expiration {
          c.mu.RUnlock()
          return nil, false
       }
    }
    c.mu.RUnlock()
    return item.Object, true
}

// Add an item to the cache, replacing any existing item. If the duration is 0
// 將item添加到緩存中，以更換任何現(xiàn)有item。如果duration持續(xù)時(shí)間為0
// (DefaultExpiration), the cache's default expiration time is used. If it is -1
// (DefaultExpiration），使用緩存的默認(rèn)到期時(shí)間。如果是-1
// (NoExpiration), the item never expires.
// （否開發(fā)），該項(xiàng)目永遠(yuǎn)不會(huì)到期。
func (c *cache) Set(k string, x interface{}, d time.Duration) {
    // "Inlining" of set
    var e int64
    if d == DefaultExpiration {
       d = c.defaultExpiration
    }
    if d > 0 {
       e = time.Now().Add(d).UnixNano()
    }
    c.mu.Lock()
    c.items[k] = Item{
       Object:     x,
       Expiration: e,
    }
    // TODO: Calls to mu.Unlock are currently not deferred because defer
    // adds ~200 ns (as of go1.)
    c.mu.Unlock()
}