Allow subsequent calls to Start and Stop (#177)

Added a new flag to support calling stopped cache cleanup procedures as well as a mutex to control it. Now:

- Start method will only run once even with the subsequent calls to it.
- Stop will never block, in case the Start was not called or Stop was called before, it will return as the cache cleanup process is not running.

Closes #175

Author: davseby

cache.go

@@ -55,14 +55,18 @@ type Cache[K comparable, V any] struct {
 		}
 	}
 
+	stopMu  sync.Mutex
 	stopCh  chan struct{}
+	stopped bool
+
 	options options[K, V]
 }
 
 // New creates a new instance of cache.
 func New[K comparable, V any](opts ...Option[K, V]) *Cache[K, V] {
 	c := &Cache[K, V]{
-		stopCh: make(chan struct{}),
+		stopCh:  make(chan struct{}),
+		stopped: true, // cache cleanup process is stopped by default
 	}
 	c.items.values = make(map[K]*list.Element)
 	c.items.lru = list.New()
@@ -621,6 +625,15 @@ func (c *Cache[K, V]) Metrics() Metrics {
 // expired items.
 // It blocks until Stop is called.
 func (c *Cache[K, V]) Start() {
+	c.stopMu.Lock()
+	if !c.stopped {
+		c.stopMu.Unlock()
+		return
+	}
+
+	c.stopped = false
+	c.stopMu.Unlock()
+
 	waitDur := func() time.Duration {
 		c.items.mu.RLock()
 		defer c.items.mu.RUnlock()
@@ -674,7 +687,16 @@ func (c *Cache[K, V]) Start() {
 // Stop stops the automatic cleanup process.
 // It blocks until the cleanup process exits.
 func (c *Cache[K, V]) Stop() {
+	c.stopMu.Lock()
+	defer c.stopMu.Unlock()
+
+	if c.stopped {
+		return
+	}
+
 	c.stopCh <- struct{}{}
+	c.stopped = true
+
 }
 
 // OnInsertion adds the provided function to be executed when

cache_test.go

@@ -1029,13 +1029,34 @@ func Test_Cache_Start(t *testing.T) {
 	cache.events.eviction.fns[1] = fn
 
 	cache.Start()
+
+	cache.events.eviction.fns = make(map[uint64]func(EvictionReason, *Item[string, string]))
+	cache.stopCh = make(chan struct{})
+	cache.stopped = true
+
+	go cache.Start()
+	go cache.Start() // should be no-op
+
+	assert.Eventually(t, func() bool {
+		cache.stopMu.Lock()
+		defer cache.stopMu.Unlock()
+		return !cache.stopped
+	}, time.Second, time.Millisecond*100)
+
+	assert.NotPanics(t, cache.Stop)
+
 }
 
 func Test_Cache_Stop(t *testing.T) {
 	cache := Cache[string, string]{
-		stopCh: make(chan struct{}, 1),
+		stopCh:  make(chan struct{}, 1),
+		stopped: true,
 	}
 	cache.Stop()
+	assert.Len(t, cache.stopCh, 0)
+
+	cache.stopped = false
+	cache.Stop()
 	assert.Len(t, cache.stopCh, 1)
 }
 
@@ -1333,15 +1354,17 @@ func Test_SuppressedLoader_Load(t *testing.T) {
 }
 
 func prepCache(maxCost uint64, ttl time.Duration, keys ...string) *Cache[string, string] {
-	c := &Cache[string, string]{}
+	c := &Cache[string, string]{
+		stopped: true,
+	}
 	c.options.ttl = ttl
 	c.options.itemOpts = append(c.options.itemOpts,
 		withVersionTracking[string, string](false))
 
 	if maxCost != 0 {
 		c.options.maxCost = maxCost
 		c.options.itemOpts = append(c.options.itemOpts,
-			withCostFunc[string, string](func(item *Item[string, string]) uint64 {
+			withCostFunc(func(item *Item[string, string]) uint64 {
 				return uint64(len(item.value))
 			}))
 	}