Merge pull request #27 from Code-Hex/fix/call-janitor-run

fixed to call janitor run method

Author: Code-Hex

cache.go

@@ -2,7 +2,6 @@ package cache
 
 import (
 	"context"
-	"runtime"
 	"sync"
 	"time"
 
@@ -16,9 +15,13 @@ import (
 
 // Interface is a common-cache interface.
 type Interface[K comparable, V any] interface {
+	// Get looks up a key's value from the cache.
 	Get(key K) (value V, ok bool)
+	// Set sets a value to the cache with key. replacing any existing value.
 	Set(key K, val V)
+	// Keys returns the keys of the cache. The order is relied on algorithms.
 	Keys() []K
+	// Delete deletes the item with provided key from the cache.
 	Delete(key K)
 }
 
@@ -147,38 +150,30 @@ func WithJanitorInterval[K comparable, V any](d time.Duration) Option[K, V] {
 }
 
 // New creates a new thread safe Cache.
-// This function will be stopped an internal janitor when the cache is
-// no longer referenced anywhere.
+// The janitor will not be stopped which is created by this function. If you
+// want to stop the janitor gracefully, You should use the `NewContext` function
+// instead of this.
 //
 // There are several Cache replacement policies available with you specified any options.
 func New[K comparable, V any](opts ...Option[K, V]) *Cache[K, V] {
-	o := newOptions[K, V]()
-	for _, optFunc := range opts {
-		optFunc(o)
-	}
-	ctx, cancel := context.WithCancel(context.Background())
-	cache := &Cache[K, V]{
-		cache:   o.cache,
-		janitor: newJanitor(ctx, o.janitorInterval),
-	}
-	runtime.SetFinalizer(cache, func(self *Cache[K, V]) {
-		cancel()
-	})
-	return cache
+	return NewContext(context.Background(), opts...)
 }
 
 // NewContext creates a new thread safe Cache with context.
+// This function will be stopped an internal janitor when the context is cancelled.
 //
 // There are several Cache replacement policies available with you specified any options.
 func NewContext[K comparable, V any](ctx context.Context, opts ...Option[K, V]) *Cache[K, V] {
 	o := newOptions[K, V]()
 	for _, optFunc := range opts {
 		optFunc(o)
 	}
-	return &Cache[K, V]{
+	cache := &Cache[K, V]{
 		cache:   o.cache,
 		janitor: newJanitor(ctx, o.janitorInterval),
 	}
+	cache.janitor.run(cache.DeleteExpired)
+	return cache
 }
 
 // Get looks up a key's value from the cache.
@@ -202,12 +197,18 @@ func (c *Cache[K, V]) Get(key K) (value V, ok bool) {
 
 // DeleteExpired all expired items from the cache.
 func (c *Cache[K, V]) DeleteExpired() {
-	for _, key := range c.cache.Keys() {
+	c.mu.Lock()
+	keys := c.cache.Keys()
+	c.mu.Unlock()
+
+	for _, key := range keys {
+		c.mu.Lock()
 		// if is expired, delete it and return nil instead
 		item, ok := c.cache.Get(key)
 		if ok && item.Expired() {
 			c.cache.Delete(key)
 		}
+		c.mu.Unlock()
 	}
 }
 

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"
@@ -103,3 +104,20 @@ func TestMultiThread(t *testing.T) {
 		})
 	}
 }
+
+func TestCallJanitor(t *testing.T) {
+	c := cache.New(
+		cache.WithJanitorInterval[string, int](100 * time.Millisecond),
+	)
+
+	c.Set("1", 10, cache.WithExpiration(10*time.Millisecond))
+	c.Set("2", 20, cache.WithExpiration(20*time.Millisecond))
+	c.Set("3", 30, cache.WithExpiration(30*time.Millisecond))
+
+	<-time.After(300 * time.Millisecond)
+
+	keys := c.Keys()
+	if len(keys) != 0 {
+		t.Errorf("want items is empty but got %d", len(keys))
+	}
+}

janitor.go

@@ -23,10 +23,12 @@ func newJanitor(ctx context.Context, interval time.Duration) *janitor {
 	return j
 }
 
+// stop to stop the janitor.
 func (j *janitor) stop() {
 	j.once.Do(func() { close(j.done) })
 }
 
+// run with the given cleanup callback function.
 func (j *janitor) run(cleanup func()) {
 	go func() {
 		ticker := time.NewTicker(j.interval)