cache

type Callbacks ¶

type Callbacks struct {
	LookupsCallback         EventCallback
	HitsCallback            EventCallback
	MissesCallback          EventCallback
	ForcedEvictionsCallback simplelru.EvictCallback
	ManualEvictionsCallback EventCallback
}

Callbacks stores various callbacks that may fire during the lifetime of an LRUCache.

NOTE: You must make sure that your callbacks are able to return quickly, because having slow callbacks will result in degraded cache performance (because the cache invokes your callbacks synchronously). The reason why we do this synchronously (and not invoke callbacks in a separate goroutine ourselves) is because we want to give users the flexibility to do that themselves. Hard-coding in a `go ...` invocation in our callback call sites would risk unnecessarily costing performance if the callbacks themselves are already optimized to return quickly.

type EventCallback ¶

type EventCallback func(key interface{})

EventCallback is similar to simplelru.EvictCallback, except that it doesn't take a value argument.

type LRUCache ¶

type LRUCache struct {
	*sync.Mutex
	*simplelru.LRU
	// contains filtered or unexported fields
}

LRUCache is the actual concurrent non-blocking cache.

func NewLRUCache(size int,
	callbacks Callbacks) (*LRUCache, error)

func (lruCache *LRUCache) GetOrAdd(
	key interface{},
	valConstructor ValConstructor) (interface{}, bool, error)

type Promise ¶

type Promise struct {
	// contains filtered or unexported fields
}

Promise is a wrapper around cache value construction; it is used to synchronize the to-be-cached value between the first thread that undergoes a cache miss and subsequent threads that attempt to look up the same cache entry (cache hit). When the Promise is resolved (when the "valConstructionPending" channel is closed), the value is ready for concurrent reads.

type ValConstructor ¶

type ValConstructor func() (interface{}, error)

ValConstructor is used to construct a value. The assumption is that this ValConstructor is expensive to compute, and that we need to memoize it via the LRUCache. The raw values of a cache are only constructed after a cache miss (and only the first cache miss). Using this type allows us to use any arbitrary function whose resulting value needs to be memoized (saved in the cache). This type also allows us to delay running the expensive computation until we actually need it (after a cache miss).