緩存失效策略在 Java 中如何實現

在Java中，緩存失效策略可以通過多種方式實現，以下是一些常見的策略：

1. 基于時間的失效（Time-based expiration）：

   在這種策略中，為緩存中的每個條目設置一個過期時間。當條目過期后，下一次訪問該條目時，將觸發重新加載或更新緩存?？梢允褂?code>java.util.concurrent.TimeUnit來設置過期時間。

   示例代碼：

   public class TimeBasedCache<K, V> {
       private final Map<K, CacheEntry<V>> cache = new ConcurrentHashMap<>();
       private final long expirationTime;
   
       public TimeBasedCache(long expirationTime, TimeUnit timeUnit) {
           this.expirationTime = System.currentTimeMillis() + timeUnit.toMillis(expirationTime);
       }
   
       public V get(K key) {
           CacheEntry<V> entry = cache.get(key);
           if (entry == null || entry.isExpired()) {
               return loadFromSource(key);
           }
           return entry.getValue();
       }
   
       private V loadFromSource(K key) {
           // 從數據源加載數據的邏輯
           return null;
       }
   
       public void put(K key, V value) {
           cache.put(key, new CacheEntry<>(value, expirationTime));
       }
   
       private static class CacheEntry<V> {
           private final V value;
           private final long expirationTime;
   
           public CacheEntry(V value, long expirationTime) {
               this.value = value;
               this.expirationTime = expirationTime;
           }
   
           public boolean isExpired() {
               return System.currentTimeMillis() > expirationTime;
           }
       }
   }
   

2. 基于大小的失效（Size-based expiration）：

   在這種策略中，當緩存達到其最大容量時，將按照一定的策略移除最舊的條目?？梢允褂?code>LinkedHashMap來實現基于大小的失效。

   示例代碼：

   public class SizeBasedCache<K, V> extends LinkedHashMap<K, V> {
       private final int maxSize;
   
       public SizeBasedCache(int maxSize) {
           super(maxSize, 0.75f, true);
           this.maxSize = maxSize;
       }
   
       @Override
       protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
           return size() > maxSize;
       }
   }
   

3. 基于訪問頻率的失效（Frequency-based expiration）：

   在這種策略中，根據緩存條目的訪問頻率來決定何時移除該條目?？梢允褂?code>HashMap和LinkedHashMap的組合來實現基于訪問頻率的失效。

   示例代碼：

   public class FrequencyBasedCache<K, V> {
       private final Map<K, CacheEntry<V>> cache = new ConcurrentHashMap<>();
       private final int maxFrequency;
   
       public FrequencyBasedCache(int maxFrequency) {
           this.maxFrequency = maxFrequency;
       }
   
       public V get(K key) {
           CacheEntry<V> entry = cache.get(key);
           if (entry == null || entry.getFrequency() >= maxFrequency) {
               return loadFromSource(key);
           }
           entry.incrementFrequency();
           return entry.getValue();
       }
   
       private V loadFromSource(K key) {
           // 從數據源加載數據的邏輯
           return null;
       }
   
       public void put(K key, V value) {
           cache.put(key, new CacheEntry<>(value, maxFrequency));
       }
   
       private static class CacheEntry<V> {
           private final V value;
           private int frequency;
           private final int maxFrequency;
   
           public CacheEntry(V value, int maxFrequency) {
               this.value = value;
               this.maxFrequency = maxFrequency;
               this.frequency = 1;
           }
   
           public int getFrequency() {
               return frequency;
           }
   
           public void incrementFrequency() {
               frequency++;
           }
       }
   }
   

這些策略可以單獨使用，也可以組合使用以滿足特定應用程序的需求。在實際應用中，可以根據具體情況選擇合適的緩存失效策略。