The freecache project is a fast, concurrent, in-memory cache library written in Go. It is designed to provide a simple and efficient way to cache data in memory, with a focus on performance and low memory usage.

Pros

• High Performance: The library is designed to be highly performant, with low latency and high throughput.
• Concurrency: The cache supports concurrent access, allowing multiple goroutines to access and modify the cache simultaneously.
• Low Memory Usage: The cache is optimized for low memory usage, making it suitable for use in resource-constrained environments.
• Simple API: The library provides a simple and intuitive API, making it easy to integrate into existing Go projects.

Cons

• Limited Features: The library is focused on providing a basic in-memory cache, and may lack some of the more advanced features found in other cache libraries.
• Lack of Persistence: The cache is in-memory only, and does not provide any built-in persistence mechanism. Data stored in the cache will be lost when the application is restarted.
• Limited Eviction Policies: The library only supports a basic LRU (Least Recently Used) eviction policy, which may not be suitable for all use cases.
• Limited Documentation: The project's documentation could be more comprehensive, making it harder for new users to get started.

Code Examples

Here are a few examples of how to use the freecache library:

// Initialize a new cache with a maximum size of 100MB
cache := freecache.NewCache(100 * 1024 * 1024)

// Set a key-value pair in the cache
cache.Set([]byte("key"), []byte("value"), 60) // 60 seconds expiration time

// Get a value from the cache
value, err := cache.Get([]byte("key"))
if err != nil {
    fmt.Println("Error getting value:", err)
} else {
    fmt.Println("Value:", string(value))
}

// Delete a key-value pair from the cache
cache.Del([]byte("key"))

// Iterate over all the keys in the cache
cache.IterateKeys(func(key []byte, expire int64) bool {
    fmt.Println("Key:", string(key), "Expire:", expire)
    return true // return false to stop iteration
})

// Set a callback function to be called when a key is evicted from the cache
cache.SetEvictionCallback(func(key, value []byte) {
    fmt.Println("Evicted key:", string(key), "value:", string(value))
})

Getting Started

To get started with the freecache library, follow these steps:

1. Install the library using Go's package manager:

go get github.com/coocood/freecache

2. Import the library in your Go code:

import "github.com/coocood/freecache"

3. Create a new cache instance with a specified maximum size:

cache := freecache.NewCache(100 * 1024 * 1024) // 100MB cache size

4. Use the cache's methods to store, retrieve, and manage data:

cache.Set([]byte("key"), []byte("value"), 60) // 60 seconds expiration time
value, err := cache.Get([]byte("key"))
cache.Del([]byte("key"))

That's the basic setup to get started with the freecache library. You can refer to the project's documentation for more advanced usage and configuration options.