A panic occurred, causing the lock to remain engaged.panic: makeslice: len out of range

[zzdeys]

What is the issue you are having?
A panic occurred, causing the lock to remain engaged. Even if I use recover from the panic, the program cannot continue running because the lock is not released. When other goroutines try to use bigcache, they cannot acquire the lock and will wait indefinitely.

traces:
/data/bkdevops/apps/golang/1.18/src/runtime/panic-go: 838 +0x207
github.com/allegro/bigcache/v2.readEntry(...)
/root/go/pkg/mod/github.com/allegro/bigcache/v2@v2.2.5/encoding-go:51
github. com/allegro/bigcache/v2. (*BigCache). providedOnRemoveWithReason(0xc55c947450, (0xc6b528cbbc, 0x34, 0X1145444}, 0x1)
/root/go/pkg/mod/github.com/allegro/bigcache/v2@v2.2.5/bigcache.go:229 +0x1ae
github.com/allegro/bigcache/v2. (*cacheShard). remove0ldestEntry(0xc5ae07e360, 0x2c73c338?)
/root/go/pkg/mod/github.com/allegro/bigcache/v2@v2.2.5/shard-go:324 +0xc9
github.com/allegro/bigcache/v2. (*cacheShard).onEvict(0x1186180?, {0xcbb528cbbc?,
0x27a5bcd3a24d8539?, 0x0?}, x0?, 0xc53c1f73e0?)
/root/go/pkg/mod/github.com/allegro/bigcache/v2@v2.2.5/shard.go:271 +0x3f
github.com/allegro/bigcache/v2. (*cacheShard).set(0xc5ae07e360, {0xcb043126c0, 0x5a}, 0x27a5bcd3a24d8539, {0xc48f9e53c8, 0x20, 0xc48f9
e53c8?})
/root/go/pkg/mod/github.com/allegro/bigcache/v2@v2.2.5/shard.go:132 +0x178
github.com/allegro/bigcache/v2. (*BigCache).Set(0xc55c947450, {0xcb043126c0, 0x5a}, {0xc48f9e53c8, 0x20, 0x20})
/root/go/pkg/mod/github.com/allegro/bigcache/v2@v2.2.5/bigcache.go:133 +0x8d

bigcache config:

Shards:             512,             
LifeWindow:         60 * time.Minute,
CleanWindow:        time.Second * 60, 
MaxEntriesInWindow: 1000 * 10 * 60,
MaxEntrySize:       4096,
Verbose:            false,
HardMaxCacheSize:   64 * 1024,

other info:
i put key to bigcache 50000/min
60000 keys in bigcache

What is BigCache doing that it shouldn't?

Minimal, Complete, and Verifiable Example

i cant provide minimal,because I cannt reliably reproduce this problem. It occurs randomly within 2 to 48 hours after the program starts.

Environment:

• Version (git sha or release): v2.2.5
• OS (e.g. from /etc/os-release or winver.exe): linux
• go version: 1.18

[ljluestc]

package main

import (
	"fmt"
	"sync"
	"time"

	"github.com/allegro/bigcache/v2"
)

// CacheWithKeys wraps BigCache with thread-safe key tracking and custom locking
type CacheWithKeys struct {
	cache    *bigcache.BigCache
	keys     map[string]struct{}
	keysLock sync.RWMutex
	// Shard locks to ensure release on panic
	shardLocks []sync.Mutex
}

// NewCacheWithKeys initializes a new CacheWithKeys
func NewCacheWithKeys(config bigcache.Config) (*CacheWithKeys, error) {
	// Wrap OnRemoveWithReason to catch panics
	config.OnRemoveWithReason = func(key string, entry []byte, reason bigcache.RemoveReason) {
		defer func() {
			if r := recover(); r != nil {
				fmt.Printf("Panic in OnRemoveWithReason: key=%s, reason=%v, error=%v\n", key, reason, r)
			}
		}()
		fmt.Printf("Removed key: %s, reason: %v\n", key, reason)
	}

	cache, err := bigcache.NewBigCache(config)
	if err != nil {
		return nil, fmt.Errorf("failed to initialize BigCache: %v", err)
	}

	// Initialize shard locks (must match number of shards)
	shardCount := config.Shards
	if shardCount == 0 {
		shardCount = 1024 // Default in BigCache v2.2.5
	}

	return &CacheWithKeys{
		cache:      cache,
		keys:       make(map[string]struct{}),
		shardLocks: make([]sync.Mutex, shardCount),
	}, nil
}

// Set stores a key-value pair with custom locking
func (c *CacheWithKeys) Set(key string, value []byte) error {
	// Compute shard index (mimics BigCache's hash-based sharding)
	hash := bigcache.DefaultHash()(key)
	shardIndex := hash % uint64(len(c.shardLocks))

	// Acquire shard lock
	c.shardLocks[shardIndex].Lock()
	defer c.shardLocks[shardIndex].Unlock()

	// Panic recovery
	defer func() {
		if r := recover(); r != nil {
			fmt.Printf("Panic in Set: key=%s, error=%v\n", key, r)
			// Lock is released by defer above
		}
	}()

	// Store in BigCache
	if err := c.cache.Set(key, value); err != nil {
		return fmt.Errorf("failed to set key %s: %v", key, err)
	}

	// Update key store
	c.keysLock.Lock()
	c.keys[key] = struct{}{}
	c.keysLock.Unlock()

	return nil
}

// Get retrieves a value
func (c *CacheWithKeys) Get(key string) ([]byte, error) {
	// Read operations are less critical, but we still use shard lock for safety
	hash := bigcache.DefaultHash()(key)
	shardIndex := hash % uint64(len(c.shardLocks))

	c.shardLocks[shardIndex].Lock()
	defer c.shardLocks[shardIndex].Unlock()

	return c.cache.Get(key)
}

// Delete removes a key-value pair
func (c *CacheWithKeys) Delete(key string) error {
	hash := bigcache.DefaultHash()(key)
	shardIndex := hash % uint64(len(c.shardLocks))

	c.shardLocks[shardIndex].Lock()
	defer c.shardLocks[shardIndex].Unlock()

	if err := c.cache.Delete(key); err != nil {
		return fmt.Errorf("failed to delete key %s: %v", key, err)
	}

	c.keysLock.Lock()
	delete(c.keys, key)
	c.keysLock.Unlock()

	return nil
}

// GetAllKeys returns all keys
func (c *CacheWithKeys) GetAllKeys() []string {
	c.keysLock.RLock()
	defer c.keysLock.RUnlock()

	keys := make([]string, 0, len(c.keys))
	for key := range c.keys {
		keys = append(keys, key)
	}
	return keys
}

func main() {
	// Configure BigCache
	config := bigcache.DefaultConfig(60 * time.Minute)
	config.Shards = 512
	config.LifeWindow = 60 * time.Minute
	config.CleanWindow = 60 * time.Second
	config.MaxEntriesInWindow = 1000 * 10 * 60
	config.MaxEntrySize = 4096
	config.HardMaxCacheSize = 64 * 1024 // 64GB
	config.Verbose = true

	// Initialize CacheWithKeys Livro
	cache, err := NewCacheWithKeys(config)
	if err != nil {
		fmt.Printf("Error initializing cache: %v\n", err)
		return
	}

	// Simulate high write load (~833 ops/sec, or 50,000/min)
	var wg sync.WaitGroup
	numWorkers := 50
	opsPerSecond := 833 / numWorkers // ~16-17 ops/sec per worker
	ticker := time.NewTicker(time.Second / time.Duration(opsPerSecond))
	defer ticker.Stop()

	for i := 0; i < numWorkers; i++ {
		wg.Add(1)
		go func(workerID int) {
			defer wg.Done()
			for j := 0; j < 1000; j++ { // Simulate ~1 minute of writes
				<-ticker.C
				key := fmt.Sprintf("key-%d-%d", workerID, j)
				value := make([]byte, 1000) // Simulate ~1KB entries
				for k := range value {
					value[k] = byte(j % 256)
				}
				if err := cache.Set(key, value); err != nil {
					fmt.Printf("Worker %d: Set error: %v\n", workerID, err)
				}
				// Simulate occasional Get
				if j%10 == 0 {
					if _, err := cache.Get(key); err != nil {
						fmt.Printf("Worker %d: Get error: %v\n", workerID, err)
					}
				}
			}
		}(i)
	}

	// Periodically print keys
	monitorTicker := time.NewTicker(10 * time.Second)
	defer monitorTicker.Stop()

	go func() {
		for range monitorTicker.C {
			keys := cache.GetAllKeys()
			fmt.Printf("Current keys (count=%d): %v\n", len(keys), keys[:min(5, len(keys))])
		}
	}()

	// Wait for workers
	wg.Wait()

	// Final key count
	keys := cache.GetAllKeys()
	fmt.Printf("Final keys (count=%d): %v\n", len(keys), keys[:min(5, len(keys))])
}

// min returns the minimum of two integers
func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}