Files
wechat/cache/memory.go
T

91 lines
1.8 KiB
Go

package cache
import (
"sync"
"time"
)
// Memory is an concurrent-safe in-process cache backed by a plain map.
type Memory struct {
mu sync.RWMutex
data map[string]*data
}
// data holds a single cached value together with its expiry time.
type data struct {
Data interface{}
Expired time.Time
}
// NewMemory returns a ready-to-use in-memory cache.
func NewMemory() *Memory {
return &Memory{
data: map[string]*data{},
}
}
// Get returns the cached value for key.
// Returns nil if the key does not exist or has expired.
func (mem *Memory) Get(key string) interface{} {
mem.mu.RLock()
ret, ok := mem.data[key]
expired := ok && ret.Expired.Before(time.Now())
mem.mu.RUnlock()
if !ok {
return nil
}
if expired {
mem.deleteExpiredKey(key)
return nil
}
return ret.Data
}
// IsExist check value exists in memcache.
func (mem *Memory) IsExist(key string) bool {
mem.mu.RLock()
ret, ok := mem.data[key]
expired := ok && ret.Expired.Before(time.Now())
mem.mu.RUnlock()
if !ok {
return false
}
if expired {
mem.deleteExpiredKey(key)
return false
}
return true
}
// Set cached value with key and expire time.
func (mem *Memory) Set(key string, val interface{}, timeout time.Duration) (err error) {
mem.mu.Lock()
defer mem.mu.Unlock()
mem.data[key] = &data{
Data: val,
Expired: time.Now().Add(timeout),
}
return nil
}
// Delete delete value in memcache.
func (mem *Memory) Delete(key string) error {
mem.mu.Lock()
defer mem.mu.Unlock()
delete(mem.data, key)
return nil
}
// deleteExpiredKey deletes a key only if it has expired.
// Caller must NOT hold any lock.
func (mem *Memory) deleteExpiredKey(key string) {
mem.mu.Lock()
defer mem.mu.Unlock()
if d, ok := mem.data[key]; ok && d.Expired.Before(time.Now()) {
delete(mem.data, key)
}
}