Cache<String, String> cache = Caffeine.newBuilder().build();

// 寫入緩存
cache.put("user:1", "Alice");

// 讀取緩存（若不存在則自動(dòng)計(jì)算）
String value = cache.get("user:1", key -> fetchFromDB(key));

Caffeine.newBuilder()
.expireAfterWrite(10, TimeUnit.MINUTES) // 寫入后10分鐘過(guò)期
.expireAfterAccess(5, TimeUnit.MINUTES) // 訪問(wèn)后5分鐘過(guò)期
.build();

AsyncLoadingCache<String, String> cache = Caffeine.newBuilder()
.refreshAfterWrite(1, TimeUnit.MINUTES) // 1分鐘后后臺(tái)刷新
.buildAsync(key -> fetchFromDB(key));

// 獲取數(shù)據(jù)（若需刷新，不會(huì)阻塞請(qǐng)求）
CompletableFuture<String> future = cache.get("user:1");

// 自動(dòng)合并并發(fā)請(qǐng)求（同一key僅一次加載）
LoadingCache<String, String> cache = Caffeine.newBuilder()
    .build(key -> {
        System.out.println("僅執(zhí)行一次: " + key);
        return fetchFromDB(key);
    });

// 并發(fā)測(cè)試（輸出1次日志）
IntStream.range(0, 100).parallel().forEach(
    i -> cache.get("user:1")
);

Cache<String, String> cache = Caffeine.newBuilder()
.recordStats() // 開(kāi)啟統(tǒng)計(jì)
.build();

cache.get("user:1");
CacheStats stats = cache.stats();
System.out.println("命中率: " + stats.hitRate());

// 使用Caffeine + RocksDB（需額外依賴）
Cache<String, byte[]> cache = Caffeine.newBuilder()
    .maximumSize(100)
    .writer(new CacheWriter<String, byte[]>() {
        @Override public void write(String key, byte[] value) {
            rocksDB.put(key.getBytes(), value); // 同步寫入磁盤
        }
        @Override public void delete(String key, byte[] value, RemovalCause cause) {
            rocksDB.delete(key.getBytes());
        }
    })
    .build();

Cache<String, String> cache = Caffeine.newBuilder()
    .removalListener((key, value, cause) -> 
        System.out.println("移除事件: " + key + " -> " + cause))
    .evictionListener((key, value, cause) -> 
        System.out.println("驅(qū)逐事件: " + key + " -> " + cause))
    .build();

import java.util.concurrent.*;
import java.util.function.Function;

public class CHMCache<K,V> {
    private final ConcurrentHashMap<K,V> map = new ConcurrentHashMap<>(16, 0.75f, 32);
    private final ScheduledExecutorService cleaner = Executors.newSingleThreadScheduledExecutor();
    
    // 基礎(chǔ)操作
    public void put(K key, V value) {
        map.put(key, value);
    }
    
    // 帶TTL的put
    public void put(K key, V value, long ttl, TimeUnit unit) {
        map.put(key, value);
        cleaner.schedule(() -> map.remove(key), ttl, unit);
    }
    
    // 自動(dòng)加載
    public V get(K key, Function<K,V> loader) {
        return map.computeIfAbsent(key, loader);
    }
    
    // 批量操作
    public void putAll(Map<? extends K, ? extends V> m) {
        map.putAll(m);
    }
    
    // 清空緩存
    public void clear() {
        map.clear();
    }
}

<dependency>
  <groupId>com.google.guava</groupId>
  <artifactId>guava</artifactId>
  <version>31.1-jre</version>
</dependency>

import com.google.common.cache.*;
import java.util.concurrent.TimeUnit;

public class GuavaCacheDemo {
    public static void main(String[] args) {
        LoadingCache<String, String> cache = CacheBuilder.newBuilder()
            .maximumSize(1000) // 最大條目數(shù)
            .expireAfterWrite(10, TimeUnit.MINUTES) // 寫入后過(guò)期時(shí)間
            .expireAfterAccess(30, TimeUnit.MINUTES) // 訪問(wèn)后過(guò)期時(shí)間
            .concurrencyLevel(8) // 并發(fā)級(jí)別
            .recordStats() // 開(kāi)啟統(tǒng)計(jì)
            .removalListener(notification -> 
                System.out.println("Removed: " + notification.getKey()))
            .build(new CacheLoader<String, String>() {
                @Override
                public String load(String key) throws Exception {
                    return loadFromDB(key);
                }
            });
        
        try {
            // 自動(dòng)加載
            String value = cache.get("user:1001");
            
            // 手動(dòng)操作
            cache.put("config:timeout", "5000");
            cache.invalidate("user:1001");
            
            // 打印統(tǒng)計(jì)
            System.out.println(cache.stats());
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
    
    private static String loadFromDB(String key) {
        // 模擬數(shù)據(jù)庫(kù)查詢
        return "DB_Result_" + key;
    }
}

<dependency>
  <groupId>com.github.ben-manes.caffeine</groupId>
  <artifactId>caffeine</artifactId>
  <version>2.9.3</version>
</dependency>

import com.github.benmanes.caffeine.cache.*;
import java.util.concurrent.TimeUnit;

public class CaffeineDemo {
    public static void main(String[] args) {
        // 同步緩存
        Cache<String, Data> cache = Caffeine.newBuilder()
            .maximumSize(10_000)
            .expireAfterWrite(5, TimeUnit.MINUTES)
            .expireAfterAccess(10, TimeUnit.MINUTES)
            .refreshAfterWrite(1, TimeUnit.MINUTES)
            .recordStats()
            .build();
        
        // 異步加載緩存
        AsyncLoadingCache<String, Data> asyncCache = Caffeine.newBuilder()
            .maximumWeight(100_000)
            .weigher((String key, Data data) -> data.size())
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .buildAsync(key -> loadFromDB(key));
        
        // 使用示例
        Data data = cache.getIfPresent("key1");
        CompletableFuture<Data> future = asyncCache.get("key1");
        
        // 打印統(tǒng)計(jì)
        System.out.println(cache.stats());
    }
    
    static class Data {
        int size() { return 1; }
    }
    
    private static Data loadFromDB(String key) {
        // 模擬數(shù)據(jù)庫(kù)加載
        return new Data();
    }
}

<dependency>
  <groupId>org.ehcache</groupId>
  <artifactId>ehcache</artifactId>
  <version>3.9.7</version>
</dependency>

import org.ehcache.*;
import org.ehcache.config.*;
import org.ehcache.config.builders.*;
import java.time.Duration;

public class EhcacheDemo {
    public static void main(String[] args) {
        // 1. 配置緩存管理器
        CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder()
            .with(CacheManagerBuilder.persistence("/tmp/ehcache-data"))
            .build();
        cacheManager.init();
        
        // 2. 配置緩存
        CacheConfiguration<String, String> config = CacheConfigurationBuilder
            .newCacheConfigurationBuilder(
                String.class, 
                String.class,
                ResourcePoolsBuilder.newResourcePoolsBuilder()
                    .heap(1000, EntryUnit.ENTRIES)  // 堆內(nèi)
                    .offheap(100, MemoryUnit.MB)    // 堆外
                    .disk(1, MemoryUnit.GB, true)   // 磁盤
            )
            .withExpiry(ExpiryPolicyBuilder.timeToLiveExpiration(Duration.ofMinutes(10)))
            .build();
        
        // 3. 創(chuàng)建緩存
        Cache<String, String> cache = cacheManager.createCache("myCache", config);
        
        // 4. 使用緩存
        cache.put("key1", "value1");
        String value = cache.get("key1");
        System.out.println(value);
        
        // 5. 關(guān)閉
        cacheManager.close();
    }
}

// 版本號(hào)校驗(yàn)示例
public Product getProduct(long id) {
CacheEntry entry = localCache.get(id);
if (entry != null) {
    int dbVersion = db.query("SELECT version FROM products WHERE id=?", id);
    if (entry.version == dbVersion) {
        return entry.product; // 版本一致，返回緩存
    }
}
// 版本不一致或緩存不存在，從數(shù)據(jù)庫(kù)加載
Product product = db.loadProduct(id);
localCache.put(id, new CacheEntry(product, product.getVersion()));
return product;
}

// 組合堆內(nèi)與堆外緩存
Cache<String, Object> multiLevelCache = Caffeine.newBuilder()
.maximumSize(10_000) // 一級(jí)緩存（堆內(nèi)）
.buildAsync(key -> {
    Object value = offHeapCache.get(key); // 二級(jí)緩存（堆外）
    if(value == null) value = loadFromDB(key);
    return value;
});

// 典型緩存數(shù)據(jù)結(jié)構(gòu)帶來(lái)的內(nèi)存開(kāi)銷
ConcurrentHashMap<String, Product> cache = new ConcurrentHashMap<>();
// 實(shí)際內(nèi)存占用 = 鍵對(duì)象 + 值對(duì)象 + 哈希表Entry對(duì)象（約額外增加40%開(kāi)銷）

// 使用OHC（Off-Heap Cache）示例
OHCache<String, Product> ohCache = OHCacheBuilder.newBuilder()
.keySerializer(new StringSerializer())
.valueSerializer(new ProductSerializer())
.capacity(1, Unit.GB)
.build();

// 按業(yè)務(wù)劃分獨(dú)立緩存實(shí)例
public class CacheRegistry {
    private static LoadingCache<String, Product> productCache = ...;  // 商品專用
    private static LoadingCache<Integer, UserProfile> userCache = ...; // 用戶專用

    // 獨(dú)立配置各緩存參數(shù)
    static {
        productCache = Caffeine.newBuilder()
        .maximumSize(10_000)
        .build(...);

        userCache = Caffeine.newBuilder()
        .maximumWeight(100MB)
        .weigher(...)
        .build(...);
    }
}