Merge pull request #17 from Code-Hex/fix/16

fixed race condition

Author: Code-Hex

cache.go

@@ -73,7 +73,7 @@ type Cache[K comparable, V any] struct {
 	cache       Interface[K, *Item[K, V]]
 	expirations map[K]chan struct{}
 	// mu is used to do lock in some method process.
-	mu sync.RWMutex
+	mu sync.Mutex
 }
 
 // Option is an option for cache.
@@ -140,8 +140,8 @@ func New[K comparable, V any](opts ...Option[K, V]) *Cache[K, V] {
 
 // Get looks up a key's value from the cache.
 func (c *Cache[K, V]) Get(key K) (value V, ok bool) {
-	c.mu.RLock()
-	defer c.mu.RUnlock()
+	c.mu.Lock()
+	defer c.mu.Unlock()
 	item, ok := c.cache.Get(key)
 	if !ok {
 		return
@@ -187,8 +187,8 @@ func (c *Cache[K, V]) doneWatchExpiration(key K) {
 
 // Keys returns the keys of the cache. the order is relied on algorithms.
 func (c *Cache[K, V]) Keys() []K {
-	c.mu.RLock()
-	defer c.mu.RUnlock()
+	c.mu.Lock()
+	defer c.mu.Unlock()
 	return c.cache.Keys()
 }
 
@@ -201,8 +201,8 @@ func (c *Cache[K, V]) Delete(key K) {
 
 // Contains reports whether key is within cache.
 func (c *Cache[K, V]) Contains(key K) bool {
-	c.mu.RLock()
-	defer c.mu.RUnlock()
+	c.mu.Lock()
+	defer c.mu.Unlock()
 	_, ok := c.cache.Get(key)
 	return ok
 }

cache_test.go

@@ -1,10 +1,16 @@
 package cache_test
 
 import (
+	"math/rand"
 	"sync"
 	"testing"
 
 	cache "github.com/Code-Hex/go-generics-cache"
+	"github.com/Code-Hex/go-generics-cache/policy/clock"
+	"github.com/Code-Hex/go-generics-cache/policy/fifo"
+	"github.com/Code-Hex/go-generics-cache/policy/lfu"
+	"github.com/Code-Hex/go-generics-cache/policy/lru"
+	"github.com/Code-Hex/go-generics-cache/policy/mru"
 )
 
 func TestMultiThreadIncr(t *testing.T) {
@@ -48,3 +54,52 @@ func TestMultiThreadDecr(t *testing.T) {
 		t.Errorf("want %v but got %v", 0, counter)
 	}
 }
+
+func TestMultiThread(t *testing.T) {
+	cases := []struct {
+		name   string
+		policy cache.Option[int, int]
+	}{
+		{
+			name:   "LRU",
+			policy: cache.AsLRU[int, int](lru.WithCapacity(10)),
+		},
+		{
+			name:   "MRU",
+			policy: cache.AsMRU[int, int](mru.WithCapacity(10)),
+		},
+		{
+			name:   "FIFO",
+			policy: cache.AsFIFO[int, int](fifo.WithCapacity(10)),
+		},
+		{
+			name:   "Clock",
+			policy: cache.AsClock[int, int](clock.WithCapacity(10)),
+		},
+		{
+			name:   "LFU",
+			policy: cache.AsLFU[int, int](lfu.WithCapacity(10)),
+		},
+	}
+	for _, tc := range cases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			c := cache.New(tc.policy)
+			var wg sync.WaitGroup
+			for i := int64(0); i < 100; i++ {
+				wg.Add(1)
+				go func(i int64) {
+					defer wg.Done()
+					m := rand.New(rand.NewSource(i))
+					for n := 0; n < 100; n++ {
+						key := m.Intn(100000)
+						c.Set(key, m.Intn(100000))
+						c.Get(key)
+					}
+				}(i)
+			}
+
+			wg.Wait()
+		})
+	}
+}