题外话：
不管学习什么语言，在基础掌握之后，阅读大牛写的开源项目确实是一种相当实在的方式(可是本人之前对此极为排斥，一直觉得要想NB还不如自己写项目，现在想来当时真是高看自己了！！)，通过研究别人的代码，不仅能学习大牛们在代码用所用到的语言知识，还能学习他们的设计思想，看到更清晰的结构！这些都是实实在在的福利！因此，阅读开源项目在我看来是必不可少的，而为了防止自己看过遗忘，同时为了更好的理解，把自己学到的记下来，方便随时查看，修正！
cache2go
这是一个使用golang实现的并发安全并且包含超时机制的缓存库、缓存方式为表，表中可存储key-value方式的数据，篇幅所限，这里仅对其中的一些核心函数做说明
github地址：
https://github.com/muesli/cache2go
源码解析：
cache.go
该文件内容很少，只实现了一个功能：返回一张缓存表，如果不存在的话，进行创建
func Cache(table string) *CacheTable {
mutex.RLock()
t, ok := cache[table] //检查是否存在
mutex.RUnlock()
if !ok {
mutex.Lock()
t, ok = cache[table] //再次检查(没看懂这里为什么要进行二次检查)
// Double check whether the table exists or not.
if !ok {
t = &CacheTable{
name: table,
items: make(map[interface{}]*CacheItem),
}
cache[table] = t
}
mutex.Unlock()
}
return t
}cacheitem.go: 该文件主要实现缓存属性
type CacheItem struct {
sync.RWMutex
// The item's key.
key interface{}
// The item's data.
data interface{}
//在一直不访问该缓存的情况下，缓存存在的生命周期
lifeSpan time.Duration
// 缓存创建时间.
createdOn time.Time
//最后一次访问时间
accessedOn time.Time
//访问次数
accessCount int64
// 回调函数，删除缓存中的数据前触发
aboutToExpire func(key interface{})
}初始化cacheItem
func NewCacheItem(key interface{}, lifeSpan time.Duration, data interface{}) *CacheItem {
t := time.Now()
return &CacheItem{
key: key,
lifeSpan: lifeSpan,
createdOn: t,
accessedOn: t,
accessCount: 0,
aboutToExpire: nil,
data: data,
}
}更新访问时间和访问次数
func (item *CacheItem) KeepAlive() {
item.Lock()
defer item.Unlock()
item.accessedOn = time.Now()
item.accessCount++
}设置aboutToExpire回调函数，可以在删除之前做自行一些处理，如备份等
func (item *CacheItem) SetAboutToExpireCallback(f func(interface{})) {
item.Lock()
defer item.Unlock()
item.aboutToExpire = f
}cachetable.go: cache实现的核心代码，对cache的CRUD操作都在这里
cache table
type CacheTable struct {
sync.RWMutex
// 表名.
name string
// 表中所有缓存数据.
items map[interface{}]*CacheItem
// 负责触发清理的定时器
cleanupTimer *time.Timer
// 当前定时器持续时间
cleanupInterval time.Duration
// 日志
logger *log.Logger
// 回调函数，当获取一个不存在的key时自动触发.
loadData func(key interface{}, args ...interface{}) *CacheItem
// 回调函数，当新增一个key时自动触发
addedItem func(item *CacheItem)
//回调函数，删除一个Key时自动触发.
aboutToDeleteItem func(item *CacheItem)
}cache大小
func (table *CacheTable) Count() int {
table.RLock()
defer table.RUnlock()
return len(table.items)
}遍历所有items，可在trans中对其进行处理
func (table *CacheTable) Foreach(trans func(key interface{}, item *CacheItem)) {
table.RLock()
defer table.RUnlock()
for k, v := range table.items {
trans(k, v)
}
}循环过期检查
func (table *CacheTable) expirationCheck() {
table.Lock()
// 停止清理定时器
if table.cleanupTimer != nil {
table.cleanupTimer.Stop()
}
if table.cleanupInterval > 0 {
table.log("Expiration check triggered after", table.cleanupInterval, "for table", table.name)
} else {
table.log("Expiration check installed for table", table.name)
}
//实时更新当前时间
now := time.Now()
smallestDuration := 0 * time.Second
for key, item := range table.items {
item.RLock()
lifeSpan := item.lifeSpan
accessedOn := item.accessedOn
item.RUnlock()
if lifeSpan == 0 {
continue
}
if now.Sub(accessedOn) >= lifeSpan {
// 超出生命周期，直接删除
table.deleteInternal(key)
} else {
// Find the item chronologically closest to its end-of-lifespan.(按时间顺序查找最接近其使用寿命的item，这里的条件感觉有点多余)
if smallestDuration == 0 || lifeSpan-now.Sub(accessedOn) < smallestDuration {
smallestDuration = lifeSpan - now.Sub(accessedOn)
}
}
}
// 设置下一次清理运行的间隔
table.cleanupInterval = smallestDuration
if smallestDuration > 0 {
table.cleanupTimer = time.AfterFunc(smallestDuration, func() {
go table.expirationCheck() //递归调用
})
}
table.Unlock()
}向缓存中添加数据
func (table *CacheTable) addInternal(item *CacheItem) {
//只能在加锁状态下调用
table.log("Adding item with key", item.key, "and lifespan of", item.lifeSpan, "to table", table.name)
table.items[item.key] = item
expDur := table.cleanupInterval
addedItem := table.addedItem
table.Unlock()
// 触发addedItem回调函数
if addedItem != nil {
addedItem(item)
}
// 设置过期检查
if item.lifeSpan > 0 && (expDur == 0 || item.lifeSpan < expDur) {
table.expirationCheck()
}
}删除指定的Key-value
func (table *CacheTable) deleteInternal(key interface{}) (*CacheItem, error) {
r, ok := table.items[key]
if !ok {
return nil, ErrKeyNotFound
}
aboutToDeleteItem := table.aboutToDeleteItem
table.Unlock()
// 触发aboutToDeleteItem函数
if aboutToDeleteItem != nil {
aboutToDeleteItem(r)
}
r.RLock()
defer r.RUnlock()
if r.aboutToExpire != nil {
// 触发r.aboutToExpire函数
r.aboutToExpire(key)
}
table.Lock()
table.log("Deleting item with key", key, "created on", r.createdOn, "and hit", r.accessCount, "times from table", table.name)
delete(table.items, key)
return r, nil
}判指定的key是否存在，不存在就添加
func (table *CacheTable) NotFoundAdd(key interface{}, lifeSpan time.Duration, data interface{}) bool {
table.Lock()
if _, ok := table.items[key]; ok {
table.Unlock()
return false
}
item := NewCacheItem(key, lifeSpan, data)
table.addInternal(item)
return true
}获取指定缓存内容
func (table *CacheTable) Value(key interface{}, args ...interface{}) (*CacheItem, error) {
table.RLock()
r, ok := table.items[key]
loadData := table.loadData
table.RUnlock()
if ok {
// 更新访问时间和访问次数
r.KeepAlive()
return r, nil
}
// 如果不存在指定key，调用loadData
if loadData != nil {
item := loadData(key, args...)
if item != nil {
table.Add(key, item.lifeSpan, item.data)
return item, nil
}
return nil, ErrKeyNotFoundOrLoadable
}
return nil, ErrKeyNotFound
}清除缓存
func (table *CacheTable) Flush() {
table.Lock()
defer table.Unlock()
table.log("Flushing table", table.name)
table.items = make(map[interface{}]*CacheItem)
table.cleanupInterval = 0
if table.cleanupTimer != nil {
table.cleanupTimer.Stop()
}
}每个Key的访问次数
type CacheItemPair struct {
Key interface{}
AccessCount int64 //访问次数
} 返回访问量由多到少到排序列表
func (table *CacheTable) MostAccessed(count int64) []*CacheItem {
table.RLock()
defer table.RUnlock()
p := make(CacheItemPairList, len(table.items))
i := 0
for k, v := range table.items {
p[i] = CacheItemPair{k, v.accessCount}
i++
}
sort.Sort(p) //降序排序
var r []*CacheItem
c := int64(0)
for _, v := range p {
if c >= count {
break
}
item, ok := table.items[v.Key]
if ok {
r = append(r, item)
}
c++
}
return r
}有疑问加站长微信联系（非本文作者）
