fix: prevent ticker leaks and correct worker pool resize behavior

Stop time.Tickers in background loops on shutdown to avoid resource leaks
WorkerPool: send only required (-diff) quit signals on shrink and buffer quit channel to reduce blocking
Includes: hypercache.go ticker lifecycle cleanup, pool.go resize logic and worker loop refactor.

Author: hyp3rd

PRD.md

@@ -0,0 +1,33 @@
+# PRD
+
+Overview
+Hypercache is a thread‑safe caching library with pluggable backends and eviction algorithms, already targeting Go 1.25 and generics. The design exposes a service interface that supports middleware layers for decorating cache operations.
+
+Findings & Suggestions
+Ticker Lifecycle – Background jobs create time.Tickers but never stop them, which can leak resources; explicitly call tick.Stop() when terminating the loops.
+
+WorkerPool Resize Logic – Resizing the pool sends a quit signal pool.workers times regardless of how many workers need removal; adjust to send -diff signals and consider buffering to avoid blocking.
+
+Expired‑Key Semantics – GetMultiple returns ErrKeyExpired, yet tests expect ErrKeyNotFound for expired items, indicating a behavior mismatch or test expectation issue.
+
+Per‑Call Goroutines – Get and GetWithInfo spawn a goroutine for each expired item, which may create overhead under heavy load; consider synchronous cleanup or a dedicated worker to batch expirations.
+
+Object Pool Hygiene – ItemPoolManager returns items to the pool without resetting fields, risking retention of large values; zero the struct before reusing it.
+
+Modern Go Features – The project already uses Go 1.25; further modernization could include:
+
+Generics for typed values rather than any, providing compile‑time safety.
+
+Use of maps.Clone/maps.DeleteFunc and slices.SortFunc for cleaner collection handling.
+
+errors.Is/errors.Join to simplify error comparisons.
+
+Potential Enhancements
+
+Expose a MGet/MSet on backends for efficient multi-key operations.
+
+Provide context-aware cancellation in WorkerPool and background jobs to ease shutdown.
+
+Add methods such as Contains, Peek, Increment, or TTL refresh APIs.
+
+Integrate OpenTelemetry metrics and tracing for observability.

hypercache.go

@@ -210,7 +210,9 @@ func (hyperCache *HyperCache[T]) startBackgroundJobs() {
 					// trigger eviction
 					hyperCache.evictionLoop(ctx)
 				case <-hyperCache.stop:
-					// stop the loops
+					// stop the loops and ticker to avoid leaks
+					tick.Stop()
+
 					return
 				}
 			}
@@ -228,6 +230,9 @@ func (hyperCache *HyperCache[T]) startBackgroundJobs() {
 					case <-tick.C:
 						hyperCache.evictionLoop(ctx)
 					case <-hyperCache.stop:
+						// stop ticker to avoid leaks
+						tick.Stop()
+
 						return
 					}
 				}

pool.go

@@ -19,9 +19,10 @@ type WorkerPool struct {
 // NewWorkerPool creates a new worker pool with the given number of workers.
 func NewWorkerPool(workers int) *WorkerPool {
 	pool := &WorkerPool{
-		workers:   workers,
-		jobs:      make(chan JobFunc, workers),
-		quit:      make(chan struct{}),
+		workers: workers,
+		jobs:    make(chan JobFunc, workers),
+		// buffer quit to allow multiple resize signals without blocking immediately
+		quit:      make(chan struct{}, workers),
 		errorChan: make(chan error, workers),
 	}
 	pool.start()
@@ -65,18 +66,12 @@ func (pool *WorkerPool) Resize(newSize int) {
 	if diff > 0 {
 		// Increase the number of workers
 		for range diff {
-			go func() {
-				for job := range pool.jobs {
-					err := job()
-					if err != nil {
-						pool.errorChan <- err
-					}
-				}
-			}()
+			go pool.worker()
 		}
 	} else {
 		// Decrease the number of workers
-		for range pool.workers {
+		// Send only the number of quit signals needed to remove workers
+		for range diff {
 			pool.quit <- struct{}{}
 		}
 	}
@@ -85,20 +80,28 @@ func (pool *WorkerPool) Resize(newSize int) {
 // start starts the worker pool.
 func (pool *WorkerPool) start() {
 	for range pool.workers {
-		go func() {
-			for {
-				select {
-				case job := <-pool.jobs:
-					err := job()
-					if err != nil {
-						pool.errorChan <- err
-					}
-
-					pool.wg.Done()
-				case <-pool.quit:
-					return
-				}
+		go pool.worker()
+	}
+}
+
+// worker is the main loop executed by each worker goroutine.
+func (pool *WorkerPool) worker() {
+	for {
+		select {
+		case job := <-pool.jobs:
+			if job == nil {
+				// jobs channel closed
+				return
 			}
-		}()
+
+			err := job()
+			if err != nil {
+				pool.errorChan <- err
+			}
+
+			pool.wg.Done()
+		case <-pool.quit:
+			return
+		}
 	}
 }