• 缓存的放置时间和删除时间

    在Java中，缓存的放置时间和删除时间是与缓存项相关的重要概念。它们用于控制缓存项在缓存中的生命周期以及何时将其从缓存中删除。以下是对这两个概念的详细介绍：

    1. 缓存的放置时间（Cache Put Time）：

      • 含义：缓存的放置时间是指当您将数据项放置（或存储）到缓存中时，记录下的时间戳。这个时间戳表示数据项被放入缓存的时间。

      • 应用：放置时间通常用于跟踪缓存项的创建时间或最后一次更新时间。它可以用于实现缓存过期策略，例如根据一定的时间段或某个具体的时间点来判断是否需要从缓存中移除数据。

      • 示例：在缓存中放置一个数据项时，您可以记录下当前的时间戳，然后在查询数据项时检查它是否过期。

    2. 缓存的删除时间（Cache Expiration Time）：

      • 含义：缓存的删除时间是指缓存项在缓存中保留的时间限制。当超过这个时间限制时，缓存会自动将数据项从缓存中删除。

      • 应用：删除时间用于实现缓存中的数据过期策略。它允许您控制缓存中的数据项在何时自动失效，以确保缓存中的数据不会变得过时或无效。

      • 示例：您可以配置缓存，使其中的数据项在放置一定时间后自动过期，以确保数据的新鲜性。

    具体实现方式取决于所选的缓存库或框架。以下是一些常见的缓存库的示例用法：

    1. Guava Cache：使用.expireAfterWrite(duration, timeUnit)配置缓存项的写入后过期时间。
    1. com.google.common.cache.Cache cache = com.google.common.cache.CacheBuilder.newBuilder()
    2.         .expireAfterWrite(10, TimeUnit.MINUTES)  // 设置缓存项在写入10分钟后过期
    3.         .build();
    1. Ehcache：使用元素配置缓存项的过期策略.
    1. "myCache"
    2.        maxEntriesLocalHeap="1000"
    3.        eternal="false"
    4.        timeToIdleSeconds="300"  
    5.        timeToLiveSeconds="600" />
    1. Caffeine：使用.expireAfterWrite(duration, timeUnit)配置缓存项的写入后过期时间。
    1. Cache cache = Caffeine.newBuilder()
    2.         .expireAfterWrite(10, TimeUnit.MINUTES)  // 设置缓存项在写入10分钟后过期
    3.         .build();

    不同的缓存库提供了不同的配置方式，但它们都支持缓存项的放置时间和删除时间的控制，以帮助管理缓存中的数据的有效性和新鲜性。根据需求，可以选择适合的缓存库并配置适当的过期策略。

    以下是一些常见的缓存管理策略和相关概念：

    • Time-to-Live（TTL）：TTL 是指缓存数据被放置后允许存在的时间长度。一旦TTL时间到期，缓存数据将被认为过期，应该被删除。TTL通常与缓存的放置时间相关，例如，一个缓存项可以有一个TTL为60秒，表示数据将在60秒后过期。

    • LRU（Least Recently Used）：LRU是一种基于访问顺序的缓存策略。当缓存空间不足时，系统会删除最近最少使用的缓存项。LRU不关心缓存项的时间戳，只关注访问的频率和顺序。

    • LFU（Least Frequently Used）：LFU是一种基于访问频率的缓存策略。它会删除访问频率最低的缓存项，无论访问时间是何时。

    • Cache Eviction（缓存淘汰）：这是指根据缓存策略从缓存中删除过期或不再需要的数据项的过程。淘汰过程根据策略和时间来计算缓存项的删除时间。

    接下来是一个完整的Java代码示例，演示了如何使用Guava Cache库创建一个缓存，包括缓存的放置时间和删除时间，以及中文注释：

    1. import com.google.common.cache.Cache;
    2. import com.google.common.cache.CacheBuilder;
    3.  
    4. import java.util.concurrent.TimeUnit;
    5.  
    6. public class CacheExample {
    7.  
    8.     public static void main(String[] args) {
    9.         // 创建Guava Cache实例，最大容量为100，数据在写入10分钟后过期
    10.         Cache cache = CacheBuilder.newBuilder()
    11.                 .maximumSize(100)
    12.                 .expireAfterWrite(10, TimeUnit.MINUTES)
    13.                 .build();
    14.  
    15.         // 向缓存中放置数据
    16.         cache.put("key1", "value1");
    17.         cache.put("key2", "value2");
    18.  
    19.         // 从缓存中获取数据
    20.         String value1 = cache.getIfPresent("key1");
    21.         String value2 = cache.getIfPresent("key2");
    22.  
    23.         // 打印获取的数据
    24.         System.out.println("key1的值：" + value1);
    25.         System.out.println("key2的值：" + value2);
    26.  
    27.         // 休眠15分钟，等待数据项过期
    28.         try {
    29.             Thread.sleep(15 * 60 * 1000);
    30.         } catch (InterruptedException e) {
    31.             e.printStackTrace();
    32.         }
    33.  
    34.         // 再次尝试获取过期的数据
    35.         String expiredValue = cache.getIfPresent("key1");
    36.  
    37.         // 打印过期的数据
    38.         System.out.println("key1的过期值：" + expiredValue);
    39.     }
    40. }

    这个示例创建了一个名为CacheExample的Java类，演示了如何使用Guava Cache库创建缓存，配置缓存项的放置时间和删除时间，并演示了缓存项的过期行为。注释已添加以帮助您理解代码的含义。

    在这个示例中：

    • 我们创建了一个Guava Cache实例，最大容量为100，数据在写入10分钟后过期。

    • 我们向缓存中放置了两个数据项，分别是"key1"和"key2"。

    • 我们从缓存中获取了这两个数据项，并打印它们的值。

    • 接着，我们使用Thread.sleep方法休眠15分钟，等待数据项过期。

    • 最后，我们再次尝试获取已过期的数据项，并打印过期的值。

    具体的缓存管理实现和删除时间的计算方式取决于使用的缓存库或框架。一般来说，你可以配置缓存的TTL或使用默认的淘汰策略来管理缓存中数据的生命周期，以确保缓存数据的有效性和性能。

    当涉及到Java语言中的缓存管理时，通常会使用各种库和框架，最常见的包括：

    1. Java Caching API (javax.cache)：Java Caching API 是 Java SE 8 的一部分，提供了一种标准的缓存管理方式。它定义了一套缓存管理接口和注解，允许开发人员在应用程序中使用不同的缓存提供程序，如Ehcache、Caffeine等。使用Java Caching API，你可以轻松地创建、配置和管理缓存，以及设置缓存的过期时间。

    2. Ehcache：Ehcache 是一个广泛使用的开源缓存库，它提供了灵活的缓存管理功能，包括缓存的放置、过期策略、磁盘持久化等。你可以使用 Ehcache 来创建本地内存缓存或分布式缓存。

    3. Caffeine：Caffeine 是一个高性能的本地内存缓存库，特别适用于需要快速访问和低延迟的应用程序。它提供了各种缓存策略，包括定时过期、基于大小的过期等。

    4. Guava Cache：Guava Cache 是 Google Guava 库的一部分，提供了简单而强大的本地内存缓存实现。它支持缓存的最大大小、定时过期、基于引用的缓存、监听器等功能。

    下面是一个使用Guava Cache的Java示例，演示了如何创建一个本地内存缓存并设置缓存的过期时间：

    1. import com.google.common.cache.Cache;
    2. import com.google.common.cache.CacheBuilder;
    3.  
    4. import java.util.concurrent.TimeUnit;
    5.  
    6. public class CacheExample {
    7.     public static void main(String[] args) {
    8.         // 创建一个Guava Cache实例
    9.         Cache cache = CacheBuilder.newBuilder()
    10.                 .maximumSize(100) // 设置缓存最大大小
    11.                 .expireAfterWrite(10, TimeUnit.MINUTES) // 设置缓存项在写入后10分钟过期
    12.                 .build();
    13.  
    14.         // 向缓存中放置数据
    15.         cache.put("key1", "value1");
    16.  
    17.         // 从缓存中获取数据
    18.         String value = cache.getIfPresent("key1");
    19.         System.out.println("Value for key1: " + value);
    20.  
    21.         // 等待一段时间，以使缓存项过期
    22.         try {
    23.             Thread.sleep(60000); // 等待1分钟
    24.         } catch (InterruptedException e) {
    25.             e.printStackTrace();
    26.         }
    27.  
    28.         // 尝试获取过期的数据
    29.         value = cache.getIfPresent("key1");
    30.         System.out.println("Value for key1 after expiration: " + value);
    31.     }
    32. }

    上面的Java示例演示了如何使用Guava Cache创建一个本地内存缓存，并设置缓存项的过期时间。让我们来分析示例中的操作和结果：

    1. 创建缓存实例：通过使用CacheBuilder类，我们创建了一个Guava Cache实例，设置了最大缓存大小为100个项，并且定义了缓存项的过期时间为10分钟。这意味着缓存中的项在10分钟后会过期。

    2. 放置数据：我们使用put方法将一个键值对("key1", "value1")放置到缓存中。

    3. 获取数据：我们使用getIfPresent方法从缓存中获取键为"key1"的值，并打印出来。在这个示例中，由于数据被刚刚放置到缓存中，所以我们可以成功获取到值，输出为"Value for key1: value1"。

    4. 等待过期：接下来，我们通过让程序休眠1分钟，模拟了过去一段时间。在这1分钟内，缓存中的数据将保持不变。

    5. 过期数据：在休眠结束后，我们再次尝试获取键为"key1"的值。这一次，由于缓存项的过期时间已经达到，我们无法再获取到它。因此，输出为"Value for key1 after expiration: null"，表示数据已经过期并且不再可用。

    这个示例演示了如何使用Guava Cache管理本地内存缓存，并设置缓存项的过期时间。这对于需要控制数据存储在内存中的时间以减少内存占用或确保数据的新鲜性非常有用。不同的应用场景可能需要不同的缓存策略，Guava Cache以及其他缓存库提供了丰富的选项来满足这些需求。

    在这个示例中，我们使用了Guava Cache创建了一个本地内存缓存，设置了最大大小和缓存项的过期时间。我们放置了一个键值对到缓存中，然后在一段时间后尝试获取它，验证了过期策略的功能。

    不同的缓存库和框架提供了各种各样的功能和配置选项，可以根据应用程序的需求选择适合的缓存解决方案。

    三级缓存：CreateBeanInstance之后：addSingletonFactory

    二级缓存：第一次从三级缓存确定对象是代理对象还是不同对象的时候，同时删除三级缓存getSingleton

    一级缓存：生成完整对象之后放到一级缓存，删除二三级缓存：addSingleton

    以下是一个使用Java示例代码，演示如何在Java中使用 java.util.HashMap 实现具有放置时间和删除时间的缓存概念。我们将自己管理缓存项的过期时间。

    1. import java.util.HashMap;
    2. import java.util.Map;
    3.  
    4. public class Cache {
    5.     private final Map> cache = new HashMap<>();
    6.     private final long defaultTtl; // 默认的过期时间（以毫秒为单位）
    7.  
    8.     public Cache(long defaultTtl) {
    9.         this.defaultTtl = defaultTtl;
    10.     }
    11.  
    12.     public void put(K key, V value) {
    13.         put(key, value, defaultTtl);
    14.     }
    15.  
    16.     public void put(K key, V value, long ttl) {
    17.         long expirationTime = System.currentTimeMillis() + ttl;
    18.         cache.put(key, new CacheEntry<>(value, expirationTime));
    19.     }
    20.  
    21.     public V get(K key) {
    22.         CacheEntry entry = cache.get(key);
    23.         if (entry != null && entry.isNotExpired()) {
    24.             return entry.getValue();
    25.         } else {
    26.             cache.remove(key);
    27.             return null;
    28.         }
    29.     }
    30.  
    31.     private static class CacheEntry {
    32.         private final V value;
    33.         private final long expirationTime;
    34.  
    35.         CacheEntry(V value, long expirationTime) {
    36.             this.value = value;
    37.             this.expirationTime = expirationTime;
    38.         }
    39.  
    40.         boolean isNotExpired() {
    41.             return System.currentTimeMillis() <= expirationTime;
    42.         }
    43.  
    44.         V getValue() {
    45.             return value;
    46.         }
    47.     }
    48.  
    49.     public static void main(String[] args) {
    50.         Cache cache = new Cache<>(60000); // 设置默认过期时间为60秒
    51.  
    52.         cache.put("key1", "value1");
    53.         cache.put("key2", "value2", 30000); // 自定义过期时间为30秒
    54.  
    55.         System.out.println("Value for key1: " + cache.get("key1")); // 输出 "value1"
    56.         System.out.println("Value for key2: " + cache.get("key2")); // 输出 "value2"
    57.  
    58.         // 等待一段时间，让部分数据过期
    59.         try {
    60.             Thread.sleep(35000);
    61.         } catch (InterruptedException e) {
    62.             e.printStackTrace();
    63.         }
    64.  
    65.         System.out.println("Value for key1: " + cache.get("key1")); // 输出 null，数据已过期
    66.         System.out.println("Value for key2: " + cache.get("key2")); // 输出 null，数据已过期
    67.     }
    68. }

    在上述示例中，我们创建了一个简单的泛型缓存类 Cache，它允许存储键值对并为每个缓存项设置过期时间。我们使用 java.util.HashMap 存储缓存项，并在获取数据时检查过期时间以确保数据有效性。当数据过期时，我们从缓存中删除它。最后，我们在 main 方法中演示了如何使用这个自定义缓存类。

    当你运行上述Java示例代码时，根据缓存项的过期时间和休眠时间，你将获得以下输出结果：

    1. Value for key1: value1
    2. Value for key2: value2
    3. Value for key1: null
    4. Value for key2: null

    解释一下这些输出结果：

    1. 首先，我们将"key1"和"key2"存储在缓存中，并设置了它们的过期时间。然后，我们通过 cache.get("key1") 和 cache.get("key2") 获取它们的值，因为它们都在有效期内，所以返回了相应的值。

    2. 然后，我们休眠了约35秒，让部分数据过期。这会导致"key1"和"key2"的缓存项过期。

    3. 最后，我们再次尝试获取"key1"和"key2"的值，由于它们的缓存项已过期，所以返回了null。这表明数据已不再可用。

  • 相关阅读:
    OpenCV实现霍夫变换
    纯Vue实现网页日常任务清单小功能（数据存储在浏览器）
    Solidity 小白教程：10. 控制流，用 solidity 实现插入排序
    加强堆的应用：topK问题
    Liunx两台服务器实现相互SSH免密登录
    MyBatis&Plus笔记
    通过FIR滤波器的输出，出现信号的延迟，校正信号的延迟量
    戴好这六顶帽子的项目经理，无论项目团队还是个人成长都受益终生
    【网络篇】第九篇——多线程版的TCP网络程序
    java-php-net-python-球鞋购物网站计算机毕业设计程序
  • 原文地址：https://blog.csdn.net/qq_57747969/article/details/132638764