The highest tagged major version is
README
¶
evcache 
This library is a work in progress.
How it works
The cache is a wrapper for sync.Map with autoexpiry, capacity limit and near-LFU eviction.
Writes to the cache do not block other reads. Each key uses its own RWMutex.
Documentation
¶
Overview ¶
Package evcache provides a non-blocking eventually consistent LFU cache.
Index ¶
- Variables
- type Builder
- type Cache
- func (c *Cache) Close() error
- func (c *Cache) Evict(key interface{})
- func (c *Cache) Fetch(key interface{}, ttl time.Duration, f FetchCallback) (value interface{}, closer io.Closer, err error)
- func (c *Cache) Flush()
- func (c *Cache) Get(key interface{}) (value interface{}, closer io.Closer, exists bool)
- func (c *Cache) Len() int
- func (c *Cache) Range(f func(key, value interface{}) bool)
- type EvictionCallback
- type FetchCallback
Constants ¶
This section is empty.
Variables ¶
var SyncInterval = time.Second
SyncInterval is the interval for background loop.
If cache overflows and records are created faster than SyncInterval, the LFU eviction starts losing order.
Functions ¶
This section is empty.
Types ¶
type Builder ¶
type Builder func(*Cache)
Builder builds a cache.
func New ¶
func New() Builder
New creates an empty cache.
Cache must be closed after usage has stopped to prevent a leaking goroutine.
It is not safe to close the cache while in use.
func (Builder) WithCapacity ¶
WithCapacity configures the cache with specified capacity. If cache exceeds the limit, the least frequently used record is evicted.
New records are inserted as the most frequently used to reduce premature eviction of new but unused records.
func (Builder) WithEvictionCallback ¶
func (build Builder) WithEvictionCallback(cb EvictionCallback) Builder
WithEvictionCallback specifies an asynchronous eviction callback.
type Cache ¶
type Cache struct {
// contains filtered or unexported fields
}
Cache is an eventually consistent LFU cache.
All methods except Close are safe to use concurrently.
func (*Cache) Close ¶
Close shuts down the cache, evicts all keys and waits for eviction callbacks to finish.
It is not safe to close the cache while in use.
func (*Cache) Fetch ¶
func (c *Cache) Fetch(key interface{}, ttl time.Duration, f FetchCallback) (value interface{}, closer io.Closer, err error)
Fetch attempts to get or set the value and calls f on a miss to receive the new value. If f returns an error, no value is cached and the error is returned back to caller.
When the returned value is not used anymore, the caller MUST call closer.Close() or a memory leak will occur.
func (*Cache) Get ¶
Get returns the value stored in the cache for a key. The boolean indicates whether a value was found.
When the returned value is not used anymore, the caller MUST call closer.Close() or a memory leak will occur.
func (*Cache) Range ¶ added in v0.1.3
Range calls f sequentially for each key and value present in the cache. If f returns false, range stops the iteration.
Range does not necessarily correspond to any consistent snapshot of the cache's contents: no key will be visited more than once, but if the value for any key is stored or deleted concurrently, Range may reflect any mapping for that key from any point during the Range call.
type EvictionCallback ¶
type EvictionCallback func(key, value interface{})
EvictionCallback is an asynchronous callback which is called after cache key eviction.
It waits until all io.Closers returned by Get or Fetch are closed.
type FetchCallback ¶
type FetchCallback func() (interface{}, error)
FetchCallback is called when *Cache.Fetch has a miss and must return a new value or an error.
It blocks the key from being accessed until the callback returns.
Source Files