fix: add Experimental GC

Author: shaj13

cache.go

@@ -2,6 +2,7 @@
 package libcache
 
 import (
+	"context"
 	"sync"
 	"time"
 
@@ -81,6 +82,58 @@ type Cache interface {
 	GC() time.Duration
 }
 
+// GC runs a garbage collection to evict expired items from the cache on time.
+//
+// GC trace expired items based on read-write barrier, therefore it listen to
+// cache write events and capture the result of calling the GC method on cache
+// to trigger the garbage collection loop at the right point in time.
+//
+// GC is a long running function, it returns when ctx done, therefore the
+// caller must start it in its own goroutine.
+//
+// Experimental
+//
+// Notice: This func is EXPERIMENTAL and may be changed or removed in a
+// later release.
+func GC(ctx context.Context, cache Cache) {
+	remaining := time.Duration(0)
+
+	t := time.NewTimer(remaining)
+	defer t.Stop()
+
+	c := make(chan Event, 1)
+	cache.Notify(c, Write)
+	defer func() {
+		cache.Ignore(c)
+		close(c)
+	}()
+
+	gc := func() {
+		remaining = cache.GC()
+		t.Stop()
+		if remaining > 0 {
+			t.Reset(remaining)
+		}
+	}
+
+	for {
+		select {
+		case e := <-c:
+			if e.Expiry.IsZero() {
+				continue
+			}
+
+			if remaining == 0 || time.Until(e.Expiry) < remaining {
+				gc()
+			}
+		case <-t.C:
+			gc()
+		case <-ctx.Done():
+			return
+		}
+	}
+}
+
 type cache struct {
 	// mu guards unsafe cache.
 	// Calls to mu.Unlock are currently not deferred,

cache_test.go

@@ -1,6 +1,7 @@
 package libcache_test
 
 import (
+	"context"
 	"fmt"
 	"math/rand"
 	"testing"
@@ -321,7 +322,7 @@ func TestNotify(t *testing.T) {
 	}
 }
 
-func TestGC(t *testing.T) {
+func TestCacheGC(t *testing.T) {
 	for _, tt := range cacheTests {
 		t.Run("Test"+tt.cont.String()+"CacheGC", func(t *testing.T) {
 			cache := tt.cont.NewUnsafe(0)
@@ -338,6 +339,27 @@ func TestGC(t *testing.T) {
 	}
 }
 
+func TestGC(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	cache := libcache.LRU.New(0)
+	go libcache.GC(ctx, cache)
+
+	cache.StoreWithTTL(1, 1, time.Millisecond*100)
+	time.Sleep(time.Millisecond * 150)
+	assert.Zero(t, cache.Len())
+
+	cache.StoreWithTTL(1, 1, time.Millisecond*100)
+	cache.StoreWithTTL(2, 2, time.Millisecond*200)
+
+	time.Sleep(time.Millisecond * 150)
+	assert.Equal(t, 1, cache.Len())
+
+	time.Sleep(time.Millisecond * 150)
+	assert.Zero(t, cache.Len())
+}
+
 func BenchmarkCache(b *testing.B) {
 	for _, tt := range cacheTests {
 		b.Run("Benchmark"+tt.cont.String()+"Cache", func(b *testing.B) {