chore: cover concurrent cache

Author: nathanverse

2-race-in-cache/main.go

@@ -1,65 +1,163 @@
-//////////////////////////////////////////////////////////////////////
-//
-// Given is some code to cache key-value pairs from a database into
-// the main memory (to reduce access time). Note that golang's map are
-// not entirely thread safe. Multiple readers are fine, but multiple
-// writers are not. Change the code to make this thread safe.
-//
-
 package main
 
 import (
 	"container/list"
+	"fmt"
+	"sync"
 	"testing"
 )
 
-// CacheSize determines how big the cache can grow
 const CacheSize = 100
 
-// KeyStoreCacheLoader is an interface for the KeyStoreCache
 type KeyStoreCacheLoader interface {
 	// Load implements a function where the cache should gets it's content from
 	Load(string) string
 }
 
+// page represents an item in our cache.
 type page struct {
 	Key   string
 	Value string
 }
 
-// KeyStoreCache is a LRU cache for string key-value pairs
+// Future represents a pending or completed result for a key.
+// It allows multiple goroutines to wait for the result of a single load operation.
+type Future struct {
+	wg     sync.WaitGroup         // Used to wait for the load to complete
+	result *list.Element          // Pointer to the list element when done
+	err    error                  // Any error during loading
+	once   sync.Once              // Ensures load is called only once
+	loader func() (string, error) // The function to perform the actual load
+}
+
+func newFuture(loader func() (string, error)) *Future {
+	f := &Future{
+		loader: loader,
+	}
+	f.wg.Add(1) // Initialize wait group for 1 completion
+	return f
+}
+
+// Do performs the actual loading operation exactly once.
+func (f *Future) Do() {
+	f.once.Do(func() {
+		// Simulate a time-consuming load operation
+		val, err := f.loader()
+		if err != nil {
+			f.err = err
+		} else {
+			f.result = &list.Element{Value: &page{"", val}}
+		}
+		f.wg.Done() // Signal that loading is complete
+	})
+}
+
+// Wait blocks until the future's operation is complete and returns the result.
+func (f *Future) Wait() (*list.Element, error) {
+	f.wg.Wait()
+	return f.result, f.err
+}
+
+// SetResult sets the list.Element once the loading is done and added to the list.
+func (f *Future) SetResult(e *list.Element) {
+	f.result = e
+}
+
+// KeyStoreCache implements a concurrent LRU cache.
 type KeyStoreCache struct {
-	cache map[string]*list.Element
-	pages list.List
-	load  func(string) string
+	mu    sync.RWMutex            // Guards access to cache and pages
+	cache map[string]*Future      // Maps key to its Future (pending or completed)
+	pages *list.List              // Doubly linked list for LRU eviction
+	load  func(key string) string // The actual resource loading function
 }
 
-// New creates a new KeyStoreCache
+// NewKeyStoreCache creates a new concurrent LRU cache.
 func New(load KeyStoreCacheLoader) *KeyStoreCache {
 	return &KeyStoreCache{
+		cache: make(map[string]*Future),
+		pages: list.New(),
 		load:  load.Load,
-		cache: make(map[string]*list.Element),
 	}
 }
 
-// Get gets the key from cache, loads it from the source if needed
+// Get retrieves a value from the cache, loading it if necessary.
 func (k *KeyStoreCache) Get(key string) string {
-	if e, ok := k.cache[key]; ok {
-		k.pages.MoveToFront(e)
-		return e.Value.(page).Value
+	// --- Phase 1: Check for existing entry (read-locked) ---
+	k.mu.RLock() // Acquire a read lock
+	f, ok := k.cache[key]
+	k.mu.RUnlock() // Release read lock quickly
+
+	if ok {
+		elem, err := f.Wait() // This blocks if the future is not yet done
+		if err != nil {
+			// Handle load error here if you want to propagate it
+			fmt.Printf("Error loading key '%s': %v\n", key, err)
+			return "" // Or re-attempt load, or return a specific error
+		}
+
+		k.mu.Lock()
+		k.pages.MoveToFront(elem)
+		k.mu.Unlock()
+
+		return elem.Value.(*page).Value
 	}
-	// Miss - load from database and save it in cache
-	p := page{key, k.load(key)}
-	// if cache is full remove the least used item
-	if len(k.cache) >= CacheSize {
-		end := k.pages.Back()
-		// remove from map
-		delete(k.cache, end.Value.(page).Key)
-		// remove from list
-		k.pages.Remove(end)
+
+	k.mu.Lock()
+	f, ok = k.cache[key]
+	if ok {
+		// Another goroutine beat us to it. Release lock and wait for its result.
+		k.mu.Unlock()
+		elem, err := f.Wait()
+		if err != nil {
+			fmt.Printf("Error loading key '%s': %v\n", key, err)
+			return ""
+		}
+		k.mu.Lock() // Re-acquire lock to move to front
+		k.pages.MoveToFront(elem)
+		k.mu.Unlock()
+		return elem.Value.(*page).Value
 	}
-	k.pages.PushFront(p)
-	k.cache[key] = k.pages.Front()
+
+	// It's genuinely not in the cache. Create a new future.
+	newF := newFuture(func() (string, error) {
+		// The actual load operation that will be called by Do()
+		val := k.load(key)
+		return val, nil // Assuming k.load doesn't return an error, adjust if it does
+	})
+	k.cache[key] = newF
+	k.mu.Unlock() // Release the write lock *before* calling Do()
+
+	newF.Do() // This will call the loader function for this key exactly once.
+
+	// Now that loading is complete, acquire write lock again to update LRU and set result.
+	k.mu.Lock()
+	defer k.mu.Unlock() // Ensure lock is released
+
+	// Check for eviction before adding the new item
+	if k.pages.Len() >= CacheSize {
+		oldest := k.pages.Back()
+		if oldest != nil {
+			pToDelete := oldest.Value.(*page)
+			delete(k.cache, pToDelete.Key) // Remove from map
+			k.pages.Remove(oldest)         // Remove from list
+			fmt.Printf("Evicting key: %s\n", pToDelete.Key)
+		}
+	}
+
+	// Get the loaded result from the future
+	loadedElem, err := newF.Wait() // This should return immediately now as Do() just completed.
+	if err != nil {
+		// Handle the error (e.g., remove from cache if load failed permanently)
+		delete(k.cache, key)
+		fmt.Printf("Final error after load for key '%s': %v\n", key, err)
+		return ""
+	}
+
+	// Add the new page to the front of the list and set its result in the future.
+	p := &page{key, loadedElem.Value.(*page).Value} // Re-create page to get its value
+	elem := k.pages.PushFront(p)
+	newF.SetResult(elem) // Set the actual list.Element in the future for future lookups
+
 	return p.Value
 }
 

7-lfu-cache/cache_test.go

@@ -1,9 +1,15 @@
 package main
 
 import (
+	"errors"
 	"fmt"
+	"math/rand"
+	"os"
 	"slices"
+	"strings"
+	"sync"
 	"testing"
+	"time"
 )
 
 func TestCache(t *testing.T) {
@@ -76,3 +82,77 @@ func TestCache1(t *testing.T) {
 		t.Errorf("keys should not contain luan")
 	}
 }
+
+const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+
+func generaterandomstringMathrand(length int) string {
+	if length <= 0 {
+		return ""
+	}
+
+	// Use strings.Builder for efficient string concatenation.
+	// It pre-allocates memory, avoiding multiple re-allocations.
+	var sb strings.Builder
+	sb.Grow(length) // Pre-allocate capacity for efficiency
+
+	charsetLen := len(charset)
+	for i := 0; i < length; i++ {
+		// Pick a random index from the charset
+		randomIndex := rand.Intn(charsetLen)
+		// Append the character at that index
+		sb.WriteByte(charset[randomIndex])
+	}
+
+	return sb.String()
+}
+
+// --- Test Main for Global Setup ---
+func TestMain(m *testing.M) {
+	// Seed the global random number generator once for all tests in this package.
+	// This is CRUCIAL for reproducible random behavior across test runs.
+	rand.New(rand.NewSource(time.Now().UnixNano()))
+
+	// Run all tests
+	code := m.Run()
+
+	// Exit with the test result code
+	os.Exit(code)
+}
+
+func TestCacheConcurrency(t *testing.T) {
+	cache, _ := NewLFUCache(5, func(key string) (string, error) {
+		return "", errors.New("Loader hasn't been implemented yet")
+	})
+
+	keyValueMap := []string{"vu", "nghia", "luan", "xanh", "orange", "thuong",
+		"tien", "lemon", "durian", "rambutant", "pear", "mango", "apple"}
+
+	var wg sync.WaitGroup
+	maxSetOperations := 10000
+	maxGetOperations := 5000
+	// Setter
+	for i := 0; i < 3; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for i := 0; i < maxSetOperations; i++ {
+				randomNumber := rand.Intn(len(keyValueMap)) + 0
+				cache.Set(keyValueMap[randomNumber], generaterandomstringMathrand(5))
+			}
+		}()
+	}
+
+	// 5 getters
+	for i := 0; i < 5; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < maxGetOperations; j++ {
+				randomNumber := rand.Intn(len(keyValueMap)) + 0
+				cache.Get(keyValueMap[randomNumber])
+			}
+		}()
+	}
+
+	wg.Wait()
+}

7-lfu-cache/main.go

@@ -18,7 +18,7 @@ type (
 )
 
 type baseCache struct {
-	mu         sync.RWMutex
+	mu         sync.Mutex
 	size       int
 	loaderFunc LoaderFunc
 	loadGroup  LoadGroup
@@ -71,15 +71,19 @@ func (cache *LFUCache) GetFreq(buckets *list.Element) int {
 }
 
 func (cache *LFUCache) Get(key string) (string, error) {
+	cache.mu.Lock()
 	if item, ok := cache.cache[key]; ok {
 		// Move item to the higher bucket
+		v := item.value
 		err := cache.moveToHigherBucket(item)
 		if err != nil {
 			return "", err
 		}
+		cache.mu.Unlock()
 
-		return item.value, nil
+		return v, nil
 	}
+	cache.mu.Unlock()
 
 	// Miss, so load value
 	value, err := cache.loaderFunc(key)
@@ -105,6 +109,9 @@ func (cache *LFUCache) GetKeys() []string {
 }
 
 func (cache *LFUCache) Set(key, value string) error {
+	cache.mu.Lock()
+	defer cache.mu.Unlock()
+
 	if item, ok := cache.cache[key]; ok {
 		item.value = value
 		return nil

playground/go.mod

@@ -0,0 +1,5 @@
+module go/playground
+
+go 1.24.2
+
+require golang.org/x/sync v0.15.0

playground/go.sum

@@ -0,0 +1,2 @@
+golang.org/x/sync v0.15.0 h1:KWH3jNZsfyT6xfAfKiz6MRNmd46ByHDYaZ7KSkCtdW8=
+golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=

playground/main.go

@@ -1 +1,45 @@
-package playground
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"golang.org/x/sync/errgroup"
+)
+
+func hello() error { // hello needs to return error to be compatible with errgroup.Go
+	fmt.Println("hello world")
+	time.Sleep(time.Second * 10)
+	fmt.Println("hello world ended")
+	return nil // Return nil or an actual error
+}
+
+func hello1() error {
+	fmt.Println("hello world 1")
+	time.Sleep(time.Second * 1)
+	return errors.New("hello world 1 goes wrong")
+}
+
+func main() {
+	g, cancel := errgroup.WithContext(context.Background())
+	g.SetLimit(2) // Set a limit of 2 concurrent goroutines
+
+	// Pass the functions as values, not the result of their execution
+	g.Go(hello)  // Correct way: pass the function hello
+	g.Go(hello1) // Correct way: pass the function hello1
+
+	select {
+	case <-cancel.Done():
+		{
+			err := cancel.Err()
+			if err != nil {
+				fmt.Printf("Error occurred %s", err.Error())
+			}
+		}
+	}
+
+	_ := g.Wait()
+	fmt.Println("Done")
+}