go get github.com/muesli/cache2go
cd cache2go && go build && go test -v

package main

import (
    "github.com/muesli/cache2go"
    "fmt"
    "time"
)

type myStruct struct {
    text     string
    moreData []byte
}

func main() {
    // 创建cache缓存对象
    cache := cache2go.Cache("myCache")

    // 实例化val，将val存至cache缓存中，缓存对象的key为someKey，缓存周期为5秒(5秒过后缓存对象失效)
    val := myStruct{"This is a test!", []byte{}}
    cache.Add("someKey", 5*time.Second, &val)

    // 从缓存中检索出key为someKey的缓存对象
    res, err := cache.Value("someKey")
    if err == nil {
        fmt.Println("Found value in cache:", res.Data().(*myStruct).text)
    } else {
        fmt.Println("Error retrieving value from cache:", err)
    }

    // 等待6秒使someKey对象自动失效
    time.Sleep(6 * time.Second)
    res, err = cache.Value("someKey")
    if err != nil {
        fmt.Println("Item is not cached (anymore).")
    }

    // 添加key为someKey的对象缓存周期为0，表示永不过期
    cache.Add("someKey", 0, &val)

    // cache2go支持一些回调和加载机制
    cache.SetAboutToDeleteItemCallback(func(e *cache2go.CacheItem) {
        fmt.Println("Deleting:", e.Key(), e.Data().(*myStruct).text, e.CreatedOn())
    })

    // 从cache缓存中移除someKey
    cache.Delete("someKey")

    // 清空整个cache缓存
    cache.Flush()
}

$ go run mycachedapp.go
Found value in cache: This is a test!
Item is not cached (anymore).
Deleting: someKey This is a test! 2016-04-29 14:20:04.758864028 +0800 CST

├── LICENSE.txt
├── README.md
├── benchmark_test.go // 压力测试程序
├── cache.go       // 缓存对象创建
├── cache_test.go  // 测试程序
├── cacheitem.go   // 缓存项
├── cachetable.go  // 缓存表
├── errors.go  // 自定义错误
└── examples  // 用法案例
    ├── callbacks
    │   └── callbacks.go
    ├── dataloader
    │   └── dataloader.go
    └── mycachedapp
        └── mycachedapp.go

// 缓存表结构体
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
    // 回调方法：当添加一个缓存对象到缓存表中时触发
    addedItem func(item *CacheItem)
    // 回调方法：当删除一个对象从缓存表中时触发
    aboutToDeleteItem func(item *CacheItem)
}

// 缓存项结构体
type CacheItem struct {
    // 读写锁
    sync.RWMutex

    // 缓存项key
    key interface{}
    // 缓存项数据
    data interface{}
    // 缓存项生命周期，0表示永不失效
    lifeSpan time.Duration

    // 缓存项创建时间戳
    createdOn time.Time
    // 缓存项访问的时间戳
    accessedOn time.Time
    // 缓存访问次数
    accessCount int64

    // 回调方法：当缓存项被移除时触发
    aboutToExpire func(key interface{})
}

var (
    cache = make(map[string]*CacheTable)
    mutex sync.RWMutex
)

// 返回一个缓存表对象
func Cache(table string) *CacheTable {
    // 创建一个新的缓存表
    mutex.RLock()
    t, ok := cache[table]
    mutex.RUnlock()

    // 如果创建不成功则实例化CacheTable
    if !ok {
        t = &CacheTable{
            name:  table,
            items: make(map[interface{}]*CacheItem),
        }

        mutex.Lock()
        cache[table] = t
        mutex.Unlock()
    }

    return t
}

// 添加一个缓存对象到缓存表中
// 参数key：缓存项的key，通过key可以找到对应的数据
// 参数liftSpan：缓存项生命周期
// 参数data：缓存项的value（数据）
// 返回：缓存对象
func (table *CacheTable) Add(key interface{}, lifeSpan time.Duration, data interface{}) *CacheItem {
    item := CreateCacheItem(key, lifeSpan, data)

    // Add item to cache.
    table.Lock()
    table.log("Adding item with key", key, "and lifespan of", lifeSpan, "to table", table.name)
    table.items[key] = &item

    // Cache values so we don't keep blocking the mutex.
    expDur := table.cleanupInterval
    addedItem := table.addedItem
    table.Unlock()

    // 触发回调函数
    if addedItem != nil {
        addedItem(&item)
    }

    // 缓存项生命周期大于0则执行缓存项生命周期检查定时器
    if lifeSpan > 0 && (expDur == 0 || lifeSpan < expDur) {
        table.expirationCheck()
    }

    return &item
}

// 创建一个缓存项对象
// 参数key：缓存项的key，通过key可以找到对应的数据
// 参数liftSpan：缓存项周期
// 参数data：缓存项的value（数据）
func CreateCacheItem(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 (table *CacheTable) SetAboutToDeleteItemCallback(f func(*CacheItem)) {
    table.Lock()
    defer table.Unlock()
    table.aboutToDeleteItem = f
}

// 删除一个缓存项从缓存表中
func (table *CacheTable) Delete(key interface{}) (*CacheItem, error) {
    table.RLock()
    r, ok := table.items[key]
    if !ok {
        table.RUnlock()
        return nil, ErrKeyNotFound
    }

    // Cache value so we don't keep blocking the mutex.
    aboutToDeleteItem := table.aboutToDeleteItem
    table.RUnlock()

    // Trigger callbacks before deleting an item from cache.
    // 触发回调函数
    if aboutToDeleteItem != nil {
        aboutToDeleteItem(r)
    }

    r.RLock()
    defer r.RUnlock()
    if r.aboutToExpire != nil {
        r.aboutToExpire(key)
    }

    table.Lock()
    defer table.Unlock()
    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
}

// 删除所有缓存项从缓存表中
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()
    }
}

if ok {
    // Update access counter and timestamp.
    r.KeepAlive()
    return r, nil
}

// 更新缓存项访问的时间戳并访问次数+1
func (item *CacheItem) KeepAlive() {
    item.Lock()
    defer item.Unlock()
    item.accessedOn = time.Now()
    item.accessCount++
}

// 缓存项生命周期检查定时器
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)
    }

    // Cache value so we don't keep blocking the mutex.
    items := table.items
    table.Unlock()

    // To be more accurate with timers, we would need to update 'now' on every
    // loop iteration. Not sure it's really efficient though.
    // 判断缓存项是否过期
    // 使用当前时间戳(now) 减去 缓存项最新访问的时间戳(accessedOn)得到的时间如果大于等于缓存项的缓存周期则说明该缓存项已经过期，删除该key。否则获取下一次清理的时间间隔(smallestDuration)
    now := time.Now()
    smallestDuration := 0 * time.Second
    for key, item := range items {
        // Cache values so we don't keep blocking the mutex.
        item.RLock()
        lifeSpan := item.lifeSpan
        accessedOn := item.accessedOn
        item.RUnlock()

        if lifeSpan == 0 {
            continue
        }
        if now.Sub(accessedOn) >= lifeSpan {
            // Item has excessed its lifespan.
            table.Delete(key)
        } else {
            // Find the item chronologically closest to its end-of-lifespan.
            if smallestDuration == 0 || lifeSpan < smallestDuration {
                smallestDuration = lifeSpan - now.Sub(accessedOn)
            }
        }
    }

    // 设置下一次清理的时间间隔
    table.Lock()
    table.cleanupInterval = smallestDuration
    if smallestDuration > 0 {
        table.cleanupTimer = time.AfterFunc(smallestDuration, func() {
            go table.expirationCheck()
        })
    }
    table.Unlock()
}