Merge pull request #22 from mingcheng/main

Author: Code-Hex

cache.go

@@ -1,6 +1,7 @@
 package cache
 
 import (
+	"runtime"
 	"sync"
 	"time"
 
@@ -12,6 +13,15 @@ import (
 	"github.com/Code-Hex/go-generics-cache/policy/simple"
 )
 
+// janitor for collecting expired items and cleaning them
+// this object is inspired from
+// https://github.com/patrickmn/go-cache/blob/46f407853014144407b6c2ec7ccc76bf67958d93/cache.go
+// many thanks to go-cache project
+type janitor struct {
+	Interval time.Duration
+	stop     chan bool
+}
+
 // Interface is a common-cache interface.
 type Interface[K comparable, V any] interface {
 	Get(key K) (value V, ok bool)
@@ -35,7 +45,7 @@ var (
 type Item[K comparable, V any] struct {
 	Key        K
 	Value      V
-	Expiration time.Duration
+	Expiration int64
 }
 
 var nowFunc = time.Now
@@ -44,14 +54,23 @@ var nowFunc = time.Now
 type ItemOption func(*itemOptions)
 
 type itemOptions struct {
-	expiration time.Duration // default none
+	expiration int64 // default none
+}
+
+// Expired returns true if the item has expired.
+func (item itemOptions) Expired() bool {
+	if item.expiration == 0 {
+		return false
+	}
+
+	return nowFunc().UnixNano() > item.expiration
 }
 
 // WithExpiration is an option to set expiration time for any items.
 // If the expiration is zero or negative value, it treats as w/o expiration.
 func WithExpiration(exp time.Duration) ItemOption {
 	return func(o *itemOptions) {
-		o.expiration = exp
+		o.expiration = nowFunc().Add(exp).UnixNano()
 	}
 }
 
@@ -70,10 +89,11 @@ func newItem[K comparable, V any](key K, val V, opts ...ItemOption) *Item[K, V]
 
 // Cache is a thread safe cache.
 type Cache[K comparable, V any] struct {
-	cache       Interface[K, *Item[K, V]]
-	expirations map[K]chan struct{}
+	cache Interface[K, *Item[K, V]]
+	//expirations map[K]chan struct{}
 	// mu is used to do lock in some method process.
-	mu sync.Mutex
+	mu      sync.Mutex
+	janitor *janitor
 }
 
 // Option is an option for cache.
@@ -132,23 +152,77 @@ func New[K comparable, V any](opts ...Option[K, V]) *Cache[K, V] {
 	for _, optFunc := range opts {
 		optFunc(o)
 	}
-	return &Cache[K, V]{
-		cache:       o.cache,
-		expirations: make(map[K]chan struct{}, 0),
+
+	cache := &Cache[K, V]{
+		cache: o.cache,
+	}
+
+	// @TODO change the ticker timer default value
+	cache.runJanitor(cache, time.Minute)
+	runtime.SetFinalizer(cache, cache.stopJanitor)
+
+	return cache
+}
+
+func (_ *Cache[K, V]) stopJanitor(c *Cache[K, V]) {
+	if c.janitor != nil {
+		c.janitor.stop <- true
+	}
+
+	c.janitor = nil
+}
+
+func (_ *Cache[K, V]) runJanitor(c *Cache[K, V], ci time.Duration) {
+	c.stopJanitor(c)
+
+	j := &janitor{
+		Interval: ci,
+		stop:     make(chan bool),
 	}
+
+	c.janitor = j
+
+	go func() {
+		ticker := time.NewTicker(j.Interval)
+		for {
+			select {
+			case <-ticker.C:
+				c.DeleteExpired()
+			case <-j.stop:
+				ticker.Stop()
+				return
+			}
+		}
+	}()
 }
 
 // Get looks up a key's value from the cache.
 func (c *Cache[K, V]) Get(key K) (value V, ok bool) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 	item, ok := c.cache.Get(key)
+
 	if !ok {
 		return
 	}
+
+	// if is expired, delete is and return nil instead
+	if item.Expiration > 0 && nowFunc().UnixNano() > item.Expiration {
+		c.cache.Delete(key)
+		return value, false
+	}
+
 	return item.Value, true
 }
 
+// DeleteExpired all expired items from the cache.
+func (c *Cache[K, V]) DeleteExpired() {
+	for _, keys := range c.cache.Keys() {
+		// delete all expired items by using get method
+		_, _ = c.Get(keys)
+	}
+}
+
 // Set sets a value to the cache with key. replacing any existing value.
 func (c *Cache[K, V]) Set(key K, val V, opts ...ItemOption) {
 	c.mu.Lock()
@@ -159,30 +233,7 @@ func (c *Cache[K, V]) Set(key K, val V, opts ...ItemOption) {
 		return
 	}
 
-	if _, ok := c.cache.Get(key); ok {
-		c.doneWatchExpiration(key)
-	}
-
 	c.cache.Set(key, item)
-	c.installExpirationWatcher(item.Key, item.Expiration)
-}
-
-func (c *Cache[K, V]) installExpirationWatcher(key K, exp time.Duration) {
-	done := make(chan struct{})
-	c.expirations[key] = done
-	go func() {
-		select {
-		case <-time.After(exp):
-			c.Delete(key)
-		case <-done:
-		}
-	}()
-}
-
-func (c *Cache[K, V]) doneWatchExpiration(key K) {
-	if ch, ok := c.expirations[key]; ok {
-		close(ch)
-	}
 }
 
 // Keys returns the keys of the cache. the order is relied on algorithms.

cache_test.go

@@ -4,6 +4,7 @@ import (
 	"math/rand"
 	"sync"
 	"testing"
+	"time"
 
 	cache "github.com/Code-Hex/go-generics-cache"
 	"github.com/Code-Hex/go-generics-cache/policy/clock"
@@ -13,6 +14,23 @@ import (
 	"github.com/Code-Hex/go-generics-cache/policy/mru"
 )
 
+func TestExpiration(t *testing.T) {
+	nc := cache.New[string, int]()
+	nc.Set("hello", 1, cache.WithExpiration(3*time.Second))
+
+	time.Sleep(time.Second * 1)
+	result, got := nc.Get("hello")
+	if !got || result != 1 {
+		t.Errorf("no, expiration must exists")
+	}
+
+	time.Sleep(time.Second * 3)
+	result, got = nc.Get("hello")
+	if got || result == 1 {
+		t.Errorf("no, expiration must not exists")
+	}
+}
+
 func TestMultiThreadIncr(t *testing.T) {
 	nc := cache.NewNumber[string, int]()
 	nc.Set("counter", 0)