精华内容
下载资源
问答
  • 如何实现本地缓存和分布式缓存? 缓存(Cache) 是指将程序或系统中常用的数据对象存储在像内存这样特定的介质中,以避免在每次程序调用时,重新创建或组织数据所带来的性能损耗,从而提高了系统的整体运行速度 以...

    如何实现本地缓存和分布式缓存?

    缓存(Cache) 是指 将程序或系统中常用的数据对象存储在像内存这样特定的介质中,以避免在每次程序调用时,重新创建或组织数据所带来的性能损耗,从而提高了系统的整体运行速度

    以目前的系统架构来说,用户的请求一般会先经过缓存系统,如果缓存中没有相关的数据,就会在其他系统中查询到相应的数据并保存在缓存中,最后返回给调用方

    本地缓存是指程序级别的缓存组件,它的特点是本地缓存和应用程序会运行在同一个进程中,所以本地缓存的操作会非常快,因为在同一个进程内也意味着不会有网络上的延迟和开销

    本地缓存适用于单节点非集群的应用场景,它的优点是,缺点是多程序无法共享缓存,比如分布式用户 Session 会话信息保存,由于每次用户访问的服务器可能是不同的,如果不能共享缓存,那么就意味着每次的请求操作都有可能被系统阻止,因为会话信息只保存在某一个服务器上,当请求没有被转发到这台存储了用户信息的服务器时,就会被认为是非登录的违规操作,除此之外,无法共享缓存可能会造成系统资源的浪费,这是因为每个系统都单独维护了一份属于自己的缓存,而同一份缓存有可能被多个系统单独进行存储,从而浪费了系统资源

    分布式缓存是指将应用系统和缓存组件进行分离的缓存机制,这样多个应用系统就可以共享一套缓存数据了,它的特点是共享缓存服务和可集群部署,为缓存系统提供了高可用的运行环境,以及缓存共享的程序运行机制

    本地缓存可以使用 EhCache 和 Google 的 Guava 来实现,而分布式缓存可以使用 Redis 或 Memcached 来实现

    由于 Redis 本身就是独立的缓存系统,因此可以作为第三方来提供共享的数据缓存,而 Redis 的分布式支持主从、哨兵和集群的模式,所以它就可以支持分布式的缓存,而 Memcached 的情况也是类似的

     

    EhCache 和 Guava 的使用及特点分析

    EhCache 是目前比较流行的开源缓存框架,是用纯 Java 语言实现的简单、快速的 Cache 组件。EhCache 支持内存缓存和磁盘缓存,支持 LRU(Least Recently Used,最近很少使用)LFU(Least Frequently Used,最近不常被使用)和 FIFO(First In First Out,先进先出)等多种淘汰算法,并且支持分布式的缓存系统EhCache 最初是独立的本地缓存框架组件,在后期的发展中(从 1.2 版)开始支持分布式缓存,分布式缓存主要支持 RMI、JGroups、EhCache Server 等方式

    LRU(最近很少使用) 和 LFU(最近不常被使用) 的区别?

    LRU 算法有一个缺点,比如说很久没有使用的一个键值,如果最近被访问了一次,那么即使它是使用次数最少的缓存,它也不会被淘汰

    而 LFU 算法解决了偶尔被访问一次之后,数据就不会被淘汰的问题,它是根据总访问次数来淘汰数据的,其核心思想是“如果数据过去被访问多次,那么将来它被访问次数也会比较多”。因此 LFU 可以理解为比 LRU 更加合理的淘汰算法

    EhCache 基础使用

    首先,需要在项目中添加 EhCache 框架,如果为 Maven 项目,则需要在 pom.xml 中添加如下配置

    <!-- https://mvnrepository.com/artifact/org.ehcache/ehcache -->
    <dependency>
        <groupId>org.ehcache</groupId>
        <artifactId>ehcache</artifactId>
        <version>3.8.1</version>
    </dependency>

    无配置参数的 EhCache 3.x 使用代码如下

    import org.ehcache.Cache;
    import org.ehcache.CacheManager;
    import org.ehcache.config.builders.CacheConfigurationBuilder;
    import org.ehcache.config.builders.CacheManagerBuilder;
    import org.ehcache.config.builders.ResourcePoolsBuilder;
    
    public class EhCacheExample {
        public static void main(String[] args) {
            // 创建缓存管理器
            CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder().build();
            // 初始化 EhCache
            cacheManager.init();
            // 创建缓存(存储器)
            Cache<String, String> myCache = cacheManager.createCache("MYCACHE",
                    CacheConfigurationBuilder.newCacheConfigurationBuilder(
                            String.class, String.class,
                            ResourcePoolsBuilder.heap(10))); // 设置缓存的最大容量
            // 设置缓存
            myCache.put("key", "Hello,Java.");
            // 读取缓存
            String value = myCache.get("key");
            // 输出缓存
            System.out.println(value);
            // 关闭缓存
            cacheManager.close();
        }
    }

    其中

    • CacheManager:是缓存管理器,可以通过单例或者多例的方式创建,也是 Ehcache 的入口类;

    • Cache:每个 CacheManager 可以管理多个 Cache,每个 Cache 可以采用 hash 的方式存储多个元素

    它们的关系如下图所示

    EhCache 的特点是,它使用起来比较简单,并且本身的 jar 包不是不大,简单的配置之后就可以正常使用了。EhCache 的使用比较灵活,它支持多种缓存策略的配置,它同时支持内存和磁盘缓存两种方式,在 EhCache 1.2 之后也开始支持分布式缓存

    Guava Cache 是 Google 开源的 Guava 里的一个子功能,它是一个内存型的本地缓存实现方案,提供了线程安全的缓存操作机制

    Guava Cache 的架构设计灵感来源于 ConcurrentHashMap,它使用了多个 segments 方式的细粒度锁,在保证线程安全的同时,支持了高并发的使用场景。Guava Cache 类似于 Map 集合的方式对键值对进行操作,只不过多了过期淘汰等处理逻辑

    在使用 Guava Cache 之前,我们需要先在 pom.xml 中添加 Guava 框架,配置如下

    <!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>28.2-jre</version>
    </dependency>

    Guava Cache 的创建有两种方式,一种是 LoadingCache,另一种是 Callable,代码示例如下

    import com.google.common.cache.*;
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.TimeUnit;
    
    public class GuavaExample {
        public static void main(String[] args) throws ExecutionException {
            // 创建方式一:LoadingCache
            LoadingCache<String, String> loadCache = CacheBuilder.newBuilder()
                    // 并发级别设置为 5,是指可以同时写缓存的线程数
                    .concurrencyLevel(5)
                    // 设置 8 秒钟过期
                    .expireAfterWrite(8, TimeUnit.SECONDS)
                    //设置缓存容器的初始容量为 10
                    .initialCapacity(10)
                    // 设置缓存最大容量为 100,超过之后就会按照 LRU 算法移除缓存项
                    .maximumSize(100)
                    // 设置要统计缓存的命中率
                    .recordStats()
                    // 设置缓存的移除通知
                    .removalListener(new RemovalListener<Object, Object>() {
                        public void onRemoval(RemovalNotification<Object, Object> notification) {
                            System.out.println(notification.getKey() + " was removed, cause is " + notification.getCause());
                        }
                    })
                    // 指定 CacheLoader,缓存不存在时,可自动加载缓存
                    .build(
                            new CacheLoader<String, String>() {
                                @Override
                                public String load(String key) throws Exception {
                                    // 自动加载缓存的业务
                                    return "cache-value:" + key;
                                }
                            }
                    );
            // 设置缓存
            loadCache.put("c1", "Hello, c1.");
            // 查询缓存
            String val = loadCache.get("c1");
            System.out.println(val);
            // 查询不存在的缓存
            String noval = loadCache.get("noval");
            System.out.println(noval);
    
            // 创建方式二:Callable
            Cache<String, String> cache = CacheBuilder.newBuilder()
                    .maximumSize(2) // 设置缓存最大长度
                    .build();
            // 设置缓存
            cache.put("k1", "Hello, k1.");
            // 查询缓存
            String value = cache.get("k1", new Callable<String>() {
                @Override
                public String call() {
                    // 缓存不存在时,执行
                    return "nil";
                }
            });
            // 输出缓存值
            System.out.println(value);
            // 查询缓存
            String nokey = cache.get("nokey", new Callable<String>() {
                @Override
                public String call() {
                    // 缓存不存在时,执行
                    return "nil";
                }
            });
            // 输出缓存值
            System.out.println(nokey);
        }
    }

    以上程序的执行结果为

    Hello, c1.
    cache-value:noval
    
    Hello, k1.
    nil

    可以看出 Guava Cache 使用了编程式的 build 生成器进行创建和管理,让使用者可以更加灵活地操纵代码,并且 Guava Cache 提供了灵活多样的个性化配置,以适应各种使用场景

     

    手动实现一个缓存系统

    需求:要自定义一个缓存,首先要考虑的是数据类型,我们可以使用 Map 集合中的 HashMapHashtable 或 ConcurrentHashMap 来实现,非并发情况下我们可以使用 HashMap,并发情况下可以使用 Hashtable 或 ConcurrentHashMap,由于 ConcurrentHashMap 的性能比 Hashtable 的高,因此在高并发环境下我们可以倾向于选择 ConcurrentHashMap,不过它们对元素的操作都是类似的

    选定了数据类型之后,我们还需要考虑缓存过期和缓存淘汰等问题,在这里我们可以借鉴 Redis 对待过期键的处理策略,目前比较常见的过期策略有以下三种

    • 定时删除

    定时删除是指在设置键值的过期时间时,创建一个定时事件,当到达过期时间后,事件处理器会执行删除过期键的操作。它的优点是可以及时的释放内存空间,缺点是需要开启多个延迟执行事件来处理清除任务,这样就会造成大量任务事件堆积,占用了很多系统资源

    • 惰性删除

    惰性删除不会主动删除过期键,而是在每次请求时才会判断此值是否过期,如果过期则删除键值,否则就返回 null。它的优点是只会占用少量的系统资源,缺点是清除不够及时,会造成一定的空间浪费

    • 定期删除

    定期删除是指每隔一段时间检查一次数据库,随机删除一些过期键值

    Redis 使用的是定期删除和惰性删除这两种策略

    自定义缓存的实现思路:首先需要定义一个存放缓存值的实体类,这个类里包含了缓存的相关信息,比如缓存的 key 和 value,缓存的存入时间、最后使用时间和命中次数(预留字段,用于支持 LFU 缓存淘汰),再使用 ConcurrentHashMap 保存缓存的 key 和 value 对象(缓存值的实体类),然后再新增一个缓存操作的工具类,用于添加和删除缓存,最后再缓存启动时,开启一个无限循环的线程用于检测并删除过期的缓存

    首先,定义一个缓存值实体类,代码如下

    import lombok.Getter;
    import lombok.Setter;
    
    /**
     * 缓存实体类
     */
    @Getter
    @Setter
    public class CacheValue implements Comparable<CacheValue> {
        // 缓存键
        private Object key;
        // 缓存值
        private Object value;
        // 最后访问时间
        private long lastTime;
        // 创建时间
        private long writeTime;
        // 存活时间
        private long expireTime;
        // 命中次数
        private Integer hitCount;
    
        @Override
        public int compareTo(CacheValue o) {
            return hitCount.compareTo(o.hitCount);
        }
    }

    然后定义一个全局缓存对象,代码如下

    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.ConcurrentMap;
    
    /**
     * Cache 全局类
     */
    public class CacheGlobal {
        // 全局缓存对象
        public static ConcurrentMap<String, MyCache> concurrentMap = new ConcurrentHashMap<>();
    }

    定义过期缓存检测类的代码如下

    import java.util.concurrent.TimeUnit;
    
    /**
     * 过期缓存检测线程
     */
    public class ExpireThread implements Runnable {
        @Override
        public void run() {
            while (true) {
                try {
                    // 每十秒检测一次
                    TimeUnit.SECONDS.sleep(10);
                    // 缓存检测和清除的方法
                    expireCache();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    
        /**
         * 缓存检测和清除的方法
         */
        private void expireCache() {
            System.out.println("检测缓存是否过期缓存");
            for (String key : CacheGlobal.concurrentMap.keySet()) {
                MyCache cache = CacheGlobal.concurrentMap.get(key);
                // 当前时间 - 写入时间
                long timoutTime = TimeUnit.NANOSECONDS.toSeconds(
                        System.nanoTime() - cache.getWriteTime());
                if (cache.getExpireTime() > timoutTime) {
                    // 没过期
                    continue;
                }
                // 清除过期缓存
                CacheGlobal.concurrentMap.remove(key);
            }
        }
    }

    接着,我们要新增一个缓存操作的工具类,用于查询和存入缓存,实现代码如下

    import org.apache.commons.lang3.StringUtils;
    import java.util.concurrent.TimeUnit;
    
    /**
     * 缓存操作工具类
     */
    public class CacheUtils {
    
        /**
         * 添加缓存
         * @param key
         * @param value
         * @param expire
         */
        public void put(String key, Object value, long expire) {
            // 非空判断,借助 commons-lang3
            if (StringUtils.isBlank(key)) return;
            // 当缓存存在时,更新缓存
            if (CacheGlobal.concurrentMap.containsKey(key)) {
                MyCache cache = CacheGlobal.concurrentMap.get(key);
                cache.setHitCount(cache.getHitCount() + 1);
                cache.setWriteTime(System.currentTimeMillis());
                cache.setLastTime(System.currentTimeMillis());
                cache.setExpireTime(expire);
                cache.setValue(value);
                return;
            }
            // 创建缓存
            MyCache cache = new MyCache();
            cache.setKey(key);
            cache.setValue(value);
            cache.setWriteTime(System.currentTimeMillis());
            cache.setLastTime(System.currentTimeMillis());
            cache.setHitCount(1);
            cache.setExpireTime(expire);
            CacheGlobal.concurrentMap.put(key, cache);
        }
    
        /**
         * 获取缓存
         * @param key
         * @return
         */
        public Object get(String key) {
            // 非空判断
            if (StringUtils.isBlank(key)) return null;
            // 字典中不存在
            if (CacheGlobal.concurrentMap.isEmpty()) return null;
            if (!CacheGlobal.concurrentMap.containsKey(key)) return null;
            MyCache cache = CacheGlobal.concurrentMap.get(key);
            if (cache == null) return null;
            // 惰性删除,判断缓存是否过期
            long timoutTime = TimeUnit.NANOSECONDS.toSeconds(
                    System.nanoTime() - cache.getWriteTime());
            // 缓存过期
            if (cache.getExpireTime() <= timoutTime) {
                // 清除过期缓存
                CacheGlobal.concurrentMap.remove(key);
                return null;
            }
            cache.setHitCount(cache.getHitCount() + 1);
            cache.setLastTime(System.currentTimeMillis());
            return cache.getValue();
        }
    }

    最后是调用缓存的测试代码

    public class MyCacheTest {
        public static void main(String[] args) {
            CacheUtils cache = new CacheUtils();
            // 存入缓存
            cache.put("key", "老王", 10);
            // 查询缓存
            String val = (String) cache.get("key");
            System.out.println(val);
            // 查询不存在的缓存
            String noval = (String) cache.get("noval");
            System.out.println(noval);
        }
    }

    以上程序的执行结果如下

    老王
    null

     

    展开全文
  • 本地缓存和分布式缓存的比较: 分布式缓存一致性更好一点,本地缓存 每个实例都有自己的缓存,可能会存在不一致的情况。 本地缓存会占用堆内存,影响垃圾回收、影响系统性能。分布式缓存两大开销会导致其慢于本地...

    本地缓存和分布式缓存的比较:

    分布式缓存一致性更好一点,本地缓存 每个实例都有自己的缓存,可能会存在不一致的情况。

    本地缓存会占用堆内存,影响垃圾回收、影响系统性能。分布式缓存两大开销会导致其慢于本地缓存,网络延迟和对象序列化

    进程内缓存适用于较小且频率可见的访问场景,尤其适用于不变对象,对于较大且不可预见的访问,最好采用分布式缓存。

     

    堆污染:

    java中,当一个可变泛型参数指向一个无泛型参数时,堆污染(Heap Pollution)就有可能发生。可能会导致ClassCastException 的发生。

     

    形变(Variance):

    java中包含三种类型的XX-Variance:

    1. 协变(covariance)

    2. 逆变(contravariance)

    3. 不变(invariance)

    这三种都是用来描述类型转换后的继承关系,其定义:如果A、B表示类型,f(.)表示类型转换,<表示继承关系,A<B表示A是由B派生出来的子类。

     

    当A<B时,有f(A)<f(b),协变

    当A<B时,有f(B)<f(A),逆变

    两个都不成立,不变。

    展开全文
  • 缓存既然如此重要,那本课时我们就来重点看一下,应该如何实现本地缓存和分布式缓存? 典型回答 本地缓存是指程序级别的缓存组件,它的特点是本地缓存和应用程序会运行在同一个进程中,所以本地缓存的操

    缓存(Cache) 是指将程序或系统中常用的数据对象存储在像内存这样特定的介质中,以避免在每次程序调用时,重新创建或组织数据所带来的性能损耗,从而提高了系统的整体运行速度。

    以目前的系统架构来说,用户的请求一般会先经过缓存系统,如果缓存中没有相关的数据,就会在其他系统中查询到相应的数据并保存在缓存中,最后返回给调用方。

    缓存既然如此重要,那本课时我们就来重点看一下,应该如何实现本地缓存和分布式缓存?

    典型回答

    本地缓存是指程序级别的缓存组件,它的特点是本地缓存和应用程序会运行在同一个进程中,所以本地缓存的操作会非常快,因为在同一个进程内也意味着不会有网络上的延迟和开销。

    本地缓存适用于单节点非集群的应用场景,它的优点是快,缺点是多程序无法共享缓存,比如分布式用户 Session 会话信息保存,由于每次用户访问的服务器可能是不同的,如果不能共享缓存,那么就意味着每次的请求操作都有可能被系统阻止,因为会话信息只保存在某一个服务器上,当请求没有被转发到这台存储了用户信息的服务器时,就会被认为是非登录的违规操作。

    除此之外,无法共享缓存可能会造成系统资源的浪费,这是因为每个系统都单独维护了一份属于自己的缓存,而同一份缓存有可能被多个系统单独进行存储,从而浪费了系统资源。

    分布式缓存是指将应用系统和缓存组件进行分离的缓存机制,这样多个应用系统就可以共享一套缓存数据了,它的特点是共享缓存服务和可集群部署,为缓存系统提供了高可用的运行环境,以及缓存共享的程序运行机制。

    本地缓存可以使用 EhCache 和 Google 的 Guava 来实现,而分布式缓存可以使用 Redis 或 Memcached 来实现。

    由于 Redis 本身就是独立的缓存系统,因此可以作为第三方来提供共享的数据缓存,而 Redis 的分布式支持主从、哨兵和集群的模式,所以它就可以支持分布式的缓存,而 Memcached 的情况也是类似的。

    考点分析

    本课时的面试题显然不只是为了问你如何实现本地缓存和分布式缓存这么简单,主要考察的是你对缓存系统的理解,以及对缓存本质原理的洞察,和缓存相关的面试题还有这些:

    更加深入的谈谈 EhCache 和 Guava。
    如何自己手动实现一个缓存系统?

    知识扩展

    1. EhCache 和 Guava 的使用及特点分析

    EhCache 是目前比较流行的开源缓存框架,是用纯 Java 语言实现的简单、快速的 Cache 组件。EhCache 支持内存缓存和磁盘缓存,支持 LRU(Least Recently Used,最近很少使用)、LFU(Least Frequently Used,最近不常被使用)和 FIFO(First In First Out,先进先出)等多种淘汰算法,并且支持分布式的缓存系统。

    EhCache 最初是独立的本地缓存框架组件,在后期的发展中(从 1.2 版)开始支持分布式缓存,分布式缓存主要支持 RMI、JGroups、EhCache Server 等方式。

    LRU 和 LFU 的区别

    LRU 算法有一个缺点,比如说很久没有使用的一个键值,如果最近被访问了一次,那么即使它是使用次数最少的缓存,它也不会被淘汰;而 LFU 算法解决了偶尔被访问一次之后,数据就不会被淘汰的问题,它是根据总访问次数来淘汰数据的,其核心思想是“如果数据过去被访问多次,那么将来它被访问次数也会比较多”。因此 LFU 可以理解为比 LRU 更加合理的淘汰算法。

    EhCache 基础使用

    首先,需要在项目中添加 EhCache 框架,如果为 Maven 项目,则需要在 pom.xml 中添加如下配置:

    <!-- https://mvnrepository.com/artifact/org.ehcache/ehcache -->
    <dependency>
        <groupId>org.ehcache</groupId>
        <artifactId>ehcache</artifactId>
        <version>3.8.1</version>
    </dependency>
    

    无配置参数的 EhCache 3.x 使用代码如下:

    import org.ehcache.Cache;
    import org.ehcache.CacheManager;
    import org.ehcache.config.builders.CacheConfigurationBuilder;
    import org.ehcache.config.builders.CacheManagerBuilder;
    import org.ehcache.config.builders.ResourcePoolsBuilder;
    
    public class EhCacheExample {
        public static void main(String[] args) {
            // 创建缓存管理器
            CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder().build();
            // 初始化 EhCache
            cacheManager.init();
            // 创建缓存(存储器)
            Cache<String, String> myCache = cacheManager.createCache("MYCACHE",
                    CacheConfigurationBuilder.newCacheConfigurationBuilder(
                            String.class, String.class,
                            ResourcePoolsBuilder.heap(10))); // 设置缓存的最大容量
            // 设置缓存
            myCache.put("key", "Hello,Java.");
            // 读取缓存
            String value = myCache.get("key");
            // 输出缓存
            System.out.println(value);
            // 关闭缓存
            cacheManager.close();
        }
    }
    

    其中:

    CacheManager:是缓存管理器,可以通过单例或者多例的方式创建,也是 Ehcache 的入口类;
    Cache:每个 CacheManager 可以管理多个 Cache,每个 Cache 可以采用 hash 的方式存储多个元素。
    它们的关系如下图所示:
    在这里插入图片描述
    更多使用方法,请参考官方文档。

    EhCache 的特点是,它使用起来比较简单,并且本身的 jar 包不是不大,简单的配置之后就可以正常使用了。EhCache 的使用比较灵活,它支持多种缓存策略的配置,它同时支持内存和磁盘缓存两种方式,在 EhCache 1.2 之后也开始支持分布式缓存了。

    Guava Cache 是 Google 开源的 Guava 里的一个子功能,它是一个内存型的本地缓存实现方案,提供了线程安全的缓存操作机制。

    Guava Cache 的架构设计灵感来源于 ConcurrentHashMap,它使用了多个 segments 方式的细粒度锁,在保证线程安全的同时,支持了高并发的使用场景。Guava Cache 类似于 Map 集合的方式对键值对进行操作,只不过多了过期淘汰等处理逻辑。

    在使用 Guava Cache 之前,我们需要先在 pom.xml 中添加 Guava 框架,配置如下:

    <!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>28.2-jre</version>
    </dependency>
    

    Guava Cache 的创建有两种方式,一种是 LoadingCache,另一种是 Callable,代码示例如下:

    import com.google.common.cache.*;
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.TimeUnit;
    
    public class GuavaExample {
        public static void main(String[] args) throws ExecutionException {
            // 创建方式一:LoadingCache
            LoadingCache<String, String> loadCache = CacheBuilder.newBuilder()
                    // 并发级别设置为 5,是指可以同时写缓存的线程数
                    .concurrencyLevel(5)
                    // 设置 8 秒钟过期
                    .expireAfterWrite(8, TimeUnit.SECONDS)
                    //设置缓存容器的初始容量为 10
                    .initialCapacity(10)
                    // 设置缓存最大容量为 100,超过之后就会按照 LRU 算法移除缓存项
                    .maximumSize(100)
                    // 设置要统计缓存的命中率
                    .recordStats()
                    // 设置缓存的移除通知
                    .removalListener(new RemovalListener<Object, Object>() {
                        public void onRemoval(RemovalNotification<Object, Object> notification) {
                            System.out.println(notification.getKey() + " was removed, cause is " + notification.getCause());
                        }
                    })
                    // 指定 CacheLoader,缓存不存在时,可自动加载缓存
                    .build(
                            new CacheLoader<String, String>() {
                                @Override
                                public String load(String key) throws Exception {
                                    // 自动加载缓存的业务
                                    return "cache-value:" + key;
                                }
                            }
                    );
            // 设置缓存
            loadCache.put("c1", "Hello, c1.");
            // 查询缓存
            String val = loadCache.get("c1");
            System.out.println(val);
            // 查询不存在的缓存
            String noval = loadCache.get("noval");
            System.out.println(noval);
    
            // 创建方式二:Callable
            Cache<String, String> cache = CacheBuilder.newBuilder()
                    .maximumSize(2) // 设置缓存最大长度
                    .build();
            // 设置缓存
            cache.put("k1", "Hello, k1.");
            // 查询缓存
            String value = cache.get("k1", new Callable<String>() {
                @Override
                public String call() {
                    // 缓存不存在时,执行
                    return "nil";
                }
            });
            // 输出缓存值
            System.out.println(value);
            // 查询缓存
            String nokey = cache.get("nokey", new Callable<String>() {
                @Override
                public String call() {
                    // 缓存不存在时,执行
                    return "nil";
                }
            });
            // 输出缓存值
            System.out.println(nokey);
        }
    }
    

    以上程序的执行结果为:

    Hello, c1.
    cache-value:noval
    Hello, k1.
    nil
    

    可以看出 Guava Cache 使用了编程式的 build 生成器进行创建和管理,让使用者可以更加灵活地操纵代码,并且 Guava Cache 提供了灵活多样的个性化配置,以适应各种使用场景。

    2. 手动实现一个缓存系统

    上面我们讲了通过 EhCache 和 Guava 实现缓存的方式,接下来我们来看看自己如何自定义一个缓存系统,当然这里说的是自己手动实现一个本地缓存。

    要自定义一个缓存,首先要考虑的是数据类型,我们可以使用 Map 集合中的 HashMap、Hashtable 或 ConcurrentHashMap 来实现,非并发情况下我们可以使用 HashMap,并发情况下可以使用 Hashtable 或 ConcurrentHashMap,由于 ConcurrentHashMap 的性能比 Hashtable 的高,因此在高并发环境下我们可以倾向于选择 ConcurrentHashMap,不过它们对元素的操作都是类似的。

    选定了数据类型之后,我们还需要考虑缓存过期和缓存淘汰等问题,在这里我们可以借鉴 Redis 对待过期键的处理策略。

    目前比较常见的过期策略有以下三种:

    • 定时删除
    • 惰性删除
    • 定期删除

    定时删除是指在设置键值的过期时间时,创建一个定时事件,当到达过期时间后,事件处理器会执行删除过期键的操作。它的优点是可以及时的释放内存空间,缺点是需要开启多个延迟执行事件来处理清除任务,这样就会造成大量任务事件堆积,占用了很多系统资源。

    惰性删除不会主动删除过期键,而是在每次请求时才会判断此值是否过期,如果过期则删除键值,否则就返回 null。它的优点是只会占用少量的系统资源,缺点是清除不够及时,会造成一定的空间浪费。

    定期删除是指每隔一段时间检查一次数据库,随机删除一些过期键值。

    Redis 使用的是定期删除和惰性删除这两种策略,我们本课时也会参照这两种策略。

    先来说一下自定义缓存的实现思路,首先需要定义一个存放缓存值的实体类,这个类里包含了缓存的相关信息,比如缓存的 key 和 value,缓存的存入时间、最后使用时间和命中次数(预留字段,用于支持 LFU 缓存淘汰),再使用 ConcurrentHashMap 保存缓存的 key 和 value 对象(缓存值的实体类),然后再新增一个缓存操作的工具类,用于添加和删除缓存,最后再缓存启动时,开启一个无限循环的线程用于检测并删除过期的缓存,实现代码如下。

    首先,定义一个缓存值实体类,代码如下:

    import lombok.Getter;
    import lombok.Setter;
    
    /**
     * 缓存实体类
     */
    @Getter
    @Setter
    public class CacheValue implements Comparable<CacheValue> {
        // 缓存键
        private Object key;
        // 缓存值
        private Object value;
        // 最后访问时间
        private long lastTime;
        // 创建时间
        private long writeTime;
        // 存活时间
        private long expireTime;
        // 命中次数
        private Integer hitCount;
    
        @Override
        public int compareTo(CacheValue o) {
            return hitCount.compareTo(o.hitCount);
        }
    }
    

    然后定义一个全局缓存对象,代码如下:

    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.ConcurrentMap;
    
    /**
     * Cache 全局类
     */
    public class CacheGlobal {
        // 全局缓存对象
        public static ConcurrentMap<String, MyCache> concurrentMap = new ConcurrentHashMap<>();
    }
    

    定义过期缓存检测类的代码如下:

    import java.util.concurrent.TimeUnit;
    
    /**
     * 过期缓存检测线程
     */
    public class ExpireThread implements Runnable {
        @Override
        public void run() {
            while (true) {
                try {
                    // 每十秒检测一次
                    TimeUnit.SECONDS.sleep(10);
                    // 缓存检测和清除的方法
                    expireCache();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    
        /**
         * 缓存检测和清除的方法
         */
        private void expireCache() {
            System.out.println("检测缓存是否过期缓存");
            for (String key : CacheGlobal.concurrentMap.keySet()) {
                MyCache cache = CacheGlobal.concurrentMap.get(key);
                // 当前时间 - 写入时间
                long timoutTime = TimeUnit.NANOSECONDS.toSeconds(
                        System.nanoTime() - cache.getWriteTime());
                if (cache.getExpireTime() > timoutTime) {
                    // 没过期
                    continue;
                }
                // 清除过期缓存
                CacheGlobal.concurrentMap.remove(key);
            }
        }
    }
    

    接着,我们要新增一个缓存操作的工具类,用于查询和存入缓存,实现代码如下:

    import org.apache.commons.lang3.StringUtils;
    
    import java.util.concurrent.TimeUnit;
    
    /**
     * 缓存操作工具类
     */
    public class CacheUtils {
    
        /**
         * 添加缓存
         * @param key
         * @param value
         * @param expire
         */
        public void put(String key, Object value, long expire) {
            // 非空判断,借助 commons-lang3
            if (StringUtils.isBlank(key)) return;
            // 当缓存存在时,更新缓存
            if (CacheGlobal.concurrentMap.containsKey(key)) {
                MyCache cache = CacheGlobal.concurrentMap.get(key);
                cache.setHitCount(cache.getHitCount() + 1);
                cache.setWriteTime(System.currentTimeMillis());
                cache.setLastTime(System.currentTimeMillis());
                cache.setExpireTime(expire);
                cache.setValue(value);
                return;
            }
            // 创建缓存
            MyCache cache = new MyCache();
            cache.setKey(key);
            cache.setValue(value);
            cache.setWriteTime(System.currentTimeMillis());
            cache.setLastTime(System.currentTimeMillis());
            cache.setHitCount(1);
            cache.setExpireTime(expire);
            CacheGlobal.concurrentMap.put(key, cache);
        }
    
        /**
         * 获取缓存
         * @param key
         * @return
         */
        public Object get(String key) {
            // 非空判断
            if (StringUtils.isBlank(key)) return null;
            // 字典中不存在
            if (CacheGlobal.concurrentMap.isEmpty()) return null;
            if (!CacheGlobal.concurrentMap.containsKey(key)) return null;
            MyCache cache = CacheGlobal.concurrentMap.get(key);
            if (cache == null) return null;
            // 惰性删除,判断缓存是否过期
            long timoutTime = TimeUnit.NANOSECONDS.toSeconds(
                    System.nanoTime() - cache.getWriteTime());
            // 缓存过期
            if (cache.getExpireTime() <= timoutTime) {
                // 清除过期缓存
                CacheGlobal.concurrentMap.remove(k
                return null;
            }
            cache.setHitCount(cache.getHitCount() + 1);
            cache.setLastTime(System.currentTimeMillis());
            return cache.getValue();
        }
    }
    

    最后是调用缓存的测试代码:

    public class MyCacheTest {
        public static void main(String[] args) {
            CacheUtils cache = new CacheUtils();
            // 存入缓存
            cache.put("key", "老王", 10);
            // 查询缓存
            String val = (String) cache.get("key");
            System.out.println(val);
            // 查询不存在的缓存
            String noval = (String) cache.get("noval");
            System.out.println(noval);
        }
    }
    

    以上程序的执行结果如下:

    老王
    null
    

    到目前为止,自定义缓存系统就已经实现完了。

    小结

    本课时讲解了本地缓存和分布式缓存这两个概念和实现的具体方式,其中本地缓存可以通过自己手动编码或借助 Guava Cache 来实现,而分布式缓存可以使用 Redis 或 EhCache 来实现。此外,本课时重点演示了手动实现缓存代码的方式和实现思路,并使用定期删除和惰性删除策略来实现缓存的清除,希望学完本课时后能对你有所帮助。

    展开全文
  • 如何实现本地缓存和分布式缓存1)本地缓存和分布式缓存1.1)本地缓存1.1)分布式缓存2)知识扩展2.1)EhCache 和 Guava 的使用及特点分析2.2)LRU 和 LFU 的区别3)EhCache 基础使用4)手动实现一个缓存系统5)小结 ...


    缓存(Cache) 是指将程序或系统中常用的数据对象存储在像内存这样特定的介质中,以避免在每次程序调用时,重新创建或组织数据所带来的性能损耗,从而提高了系统的整体运行速度
    以目前的系统架构来说,用户的请求一般会先经过缓存系统,如果缓存中没有相关的数据,就会在其他系统中查询到相应的数据并保存在缓存中,最后返回给调用方。应该如何实现本地缓存和分布式缓存?

    1)本地缓存和分布式缓存

    1.1)本地缓存

    本地缓存是指程序级别的缓存组件,它的特点是本地缓存和应用程序会运行在同一个进程中,所以本地缓存的操作会非常快,因为在同一个进程内也意味着不会有网络上的延迟和开销。
    本地缓存适用于单节点非集群的应用场景,它的优点是快,缺点是多程序无法共享缓存,比如分布式用户 Session 会话信息保存,由于每次用户访问的服务器可能是不同的,如果不能共享缓存,那么就意味着每次的请求操作都有可能被系统阻止,因为会话信息只保存在某一个服务器上,当请求没有被转发到这台存储了用户信息的服务器时,就会被认为是非登录的违规操作。
    除此之外,无法共享缓存可能会造成系统资源的浪费,这是因为每个系统都单独维护了一份属于自己的缓存,而同一份缓存有可能被多个系统单独进行存储,从而浪费了系统资源。

    1.2)分布式缓存

    分布式缓存是指将应用系统和缓存组件进行分离的缓存机制,这样多个应用系统就可以共享一套缓存数据了,它的特点是共享缓存服务和可集群部署,为缓存系统提供了高可用的运行环境,以及缓存共享的程序运行机制。

    本地缓存可以使用 EhCache 和 Google 的 Guava 来实现,而分布式缓存可以使用 Redis 或 Memcached 来实现。
    由于 Redis 本身就是独立的缓存系统,因此可以作为第三方来提供共享的数据缓存,而 Redis 的分布式支持主从、哨兵和集群的模式,所以它就可以支持分布式的缓存,而 Memcached 的情况也是类似的。

    2)知识扩展

    2.1)EhCache 和 Guava 的使用及特点分析

    EhCache 是目前比较流行的开源缓存框架,是用纯 Java 语言实现的简单、快速的 Cache 组件。EhCache 支持内存缓存和磁盘缓存,支持 LRU(Least Recently Used,最近很少使用)、LFU(Least Frequently Used,最近不常被使用)和 FIFO(First In First Out,先进先出)等多种淘汰算法,并且支持分布式的缓存系统。
    EhCache 最初是独立的本地缓存框架组件,在后期的发展中(从 1.2 版)开始支持分布式缓存,分布式缓存主要支持 RMI、JGroups、EhCache Server 等方式。

    2.2)LRU 和 LFU 的区别

    LRU 算法有一个缺点,比如说很久没有使用的一个键值,如果最近被访问了一次,那么即使它是使用次数最少的缓存,它也不会被淘汰;而 LFU 算法解决了偶尔被访问一次之后,数据就不会被淘汰的问题,它是根据总访问次数来淘汰数据的,其核心思想是“如果数据过去被访问多次,那么将来它被访问次数也会比较多”。因此 LFU 可以理解为比 LRU 更加合理的淘汰算法。

    3)EhCache 基础使用

    首先,需要在项目中添加 EhCache 框架,如果为 Maven 项目,则需要在 pom.xml 中添加如下配置:

    <!-- https://mvnrepository.com/artifact/org.ehcache/ehcache -->
    <dependency>
        <groupId>org.ehcache</groupId>
        <artifactId>ehcache</artifactId>
        <version>3.8.1</version>
    </dependency>
    

    无配置参数的 EhCache 3.x 使用代码如下:

    import org.ehcache.Cache;
    import org.ehcache.CacheManager;
    import org.ehcache.config.builders.CacheConfigurationBuilder;
    import org.ehcache.config.builders.CacheManagerBuilder;
    import org.ehcache.config.builders.ResourcePoolsBuilder;
    
    public class EhCacheExample {
        public static void main(String[] args) {
            // 创建缓存管理器
            CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder().build();
            // 初始化 EhCache
            cacheManager.init();
            // 创建缓存(存储器)
            Cache<String, String> myCache = cacheManager.createCache("MYCACHE",
                    CacheConfigurationBuilder.newCacheConfigurationBuilder(
                            String.class, String.class,
                            ResourcePoolsBuilder.heap(10))); // 设置缓存的最大容量
            // 设置缓存
            myCache.put("key", "Hello,Java.");
            // 读取缓存
            String value = myCache.get("key");
            // 输出缓存
            System.out.println(value);
            // 关闭缓存
            cacheManager.close();
        }
    }
    

    其中:

    • CacheManager:是缓存管理器,可以通过单例或者多例的方式创建,也是 Ehcache 的入口类;

    • Cache:每个 CacheManager 可以管理多个 Cache,每个 Cache 可以采用 hash 的方式存储多个元素。

      它们的关系如下图所示:
      在这里插入图片描述

    EhCache 的特点是,它使用起来比较简单,并且本身的 jar 包不是不大,简单的配置之后就可以正常使用了。EhCache 的使用比较灵活,它支持多种缓存策略的配置,它同时支持内存和磁盘缓存两种方式,在 EhCache 1.2 之后也开始支持分布式缓存了。
    Guava Cache 是 Google 开源的 Guava 里的一个子功能,它是一个内存型的本地缓存实现方案,提供了线程安全的缓存操作机制。
    Guava Cache 的架构设计灵感来源于 ConcurrentHashMap,它使用了多个 segments 方式的细粒度锁,在保证线程安全的同时,支持了高并发的使用场景。Guava Cache 类似于 Map 集合的方式对键值对进行操作,只不过多了过期淘汰等处理逻辑。
    在使用 Guava Cache 之前,我们需要先在 pom.xml 中添加 Guava 框架,配置如下:

    <!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>28.2-jre</version>
    </dependency>
    

    Guava Cache 的创建有两种方式,一种是 LoadingCache,另一种是 Callable,代码示例如下:

    import com.google.common.cache.*;
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.TimeUnit;
    
    public class GuavaExample {
        public static void main(String[] args) throws ExecutionException {
            // 创建方式一:LoadingCache
            LoadingCache<String, String> loadCache = CacheBuilder.newBuilder()
                    // 并发级别设置为 5,是指可以同时写缓存的线程数
                    .concurrencyLevel(5)
                    // 设置 8 秒钟过期
                    .expireAfterWrite(8, TimeUnit.SECONDS)
                    //设置缓存容器的初始容量为 10
                    .initialCapacity(10)
                    // 设置缓存最大容量为 100,超过之后就会按照 LRU 算法移除缓存项
                    .maximumSize(100)
                    // 设置要统计缓存的命中率
                    .recordStats()
                    // 设置缓存的移除通知
                    .removalListener(new RemovalListener<Object, Object>() {
                        public void onRemoval(RemovalNotification<Object, Object> notification) {
                            System.out.println(notification.getKey() + " was removed, cause is " + notification.getCause());
                        }
                    })
                    // 指定 CacheLoader,缓存不存在时,可自动加载缓存
                    .build(
                            new CacheLoader<String, String>() {
                                @Override
                                public String load(String key) throws Exception {
                                    // 自动加载缓存的业务
                                    return "cache-value:" + key;
                                }
                            }
                    );
            // 设置缓存
            loadCache.put("c1", "Hello, c1.");
            // 查询缓存
            String val = loadCache.get("c1");
            System.out.println(val);
            // 查询不存在的缓存
            String noval = loadCache.get("noval");
            System.out.println(noval);
    
            // 创建方式二:Callable
            Cache<String, String> cache = CacheBuilder.newBuilder()
                    .maximumSize(2) // 设置缓存最大长度
                    .build();
            // 设置缓存
            cache.put("k1", "Hello, k1.");
            // 查询缓存
            String value = cache.get("k1", new Callable<String>() {
                @Override
                public String call() {
                    // 缓存不存在时,执行
                    return "nil";
                }
            });
            // 输出缓存值
            System.out.println(value);
            // 查询缓存
            String nokey = cache.get("nokey", new Callable<String>() {
                @Override
                public String call() {
                    // 缓存不存在时,执行
                    return "nil";
                }
            });
            // 输出缓存值
            System.out.println(nokey);
        }
    }
    

    以上程序的执行结果为:

    Hello, c1.
    cache-value:noval
    Hello, k1.
    nil

    可以看出 Guava Cache 使用了编程式的 build 生成器进行创建和管理,让使用者可以更加灵活地操纵代码,并且 Guava Cache 提供了灵活多样的个性化配置,以适应各种使用场景。

    4)手动实现一个缓存系统

    要自定义一个缓存,首先要考虑的是数据类型,我们可以使用 Map 集合中的 HashMap、Hashtable 或 ConcurrentHashMap 来实现,非并发情况下我们可以使用 HashMap,并发情况下可以使用 Hashtable 或 ConcurrentHashMap,由于 ConcurrentHashMap 的性能比 Hashtable 的高,因此在高并发环境下我们可以倾向于选择 ConcurrentHashMap,不过它们对元素的操作都是类似的。

    选定了数据类型之后,我们还需要考虑缓存过期和缓存淘汰等问题,在这里我们可以借鉴 Redis 对待过期键的处理策略。目前比较常见的过期策略有以下三种:

    • 定时删除
    • 惰性删除
    • 定期删除

    定时删除是指在设置键值的过期时间时,创建一个定时事件,当到达过期时间后,事件处理器会执行删除过期键的操作。它的优点是可以及时的释放内存空间,缺点是需要开启多个延迟执行事件来处理清除任务,这样就会造成大量任务事件堆积,占用了很多系统资源。

    惰性删除不会主动删除过期键,而是在每次请求时才会判断此值是否过期,如果过期则删除键值,否则就返回 null。它的优点是只会占用少量的系统资源,缺点是清除不够及时,会造成一定的空间浪费。

    定期删除是指每隔一段时间检查一次数据库,随机删除一些过期键值。

    Redis 使用的是定期删除和惰性删除这两种策略,我们本课时也会参照这两种策略。

    先来说一下自定义缓存的实现思路,首先需要定义一个存放缓存值的实体类,这个类里包含了缓存的相关信息,比如缓存的 key 和 value,缓存的存入时间、最后使用时间和命中次数(预留字段,用于支持 LFU 缓存淘汰),再使用 ConcurrentHashMap 保存缓存的 key 和 value 对象(缓存值的实体类),然后再新增一个缓存操作的工具类,用于添加和删除缓存,最后再缓存启动时,开启一个无限循环的线程用于检测并删除过期的缓存,实现代码如下。

    首先,定义一个缓存值实体类,代码如下:

    import lombok.Getter;
    import lombok.Setter;
    
    /**
     * 缓存实体类
     */
    @Getter
    @Setter
    public class CacheValue implements Comparable<CacheValue> {
        // 缓存键
        private Object key;
        // 缓存值
        private Object value;
        // 最后访问时间
        private long lastTime;
        // 创建时间
        private long writeTime;
        // 存活时间
        private long expireTime;
        // 命中次数
        private Integer hitCount;
    
        @Override
        public int compareTo(CacheValue o) {
            return hitCount.compareTo(o.hitCount);
        }
    }
    

    定义过期缓存检测类的代码如下:

    import java.util.concurrent.TimeUnit;
    
    /**
     * 过期缓存检测线程
     */
    public class ExpireThread implements Runnable {
        @Override
        public void run() {
            while (true) {
                try {
                    // 每十秒检测一次
                    TimeUnit.SECONDS.sleep(10);
                    // 缓存检测和清除的方法
                    expireCache();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    
        /**
         * 缓存检测和清除的方法
         */
        private void expireCache() {
            System.out.println("检测缓存是否过期缓存");
            for (String key : CacheGlobal.concurrentMap.keySet()) {
                MyCache cache = CacheGlobal.concurrentMap.get(key);
                // 当前时间 - 写入时间
                long timoutTime = TimeUnit.NANOSECONDS.toSeconds(
                        System.nanoTime() - cache.getWriteTime());
                if (cache.getExpireTime() > timoutTime) {
                    // 没过期
                    continue;
                }
                // 清除过期缓存
                CacheGlobal.concurrentMap.remove(key);
            }
        }
    }
    

    接着,我们要新增一个缓存操作的工具类,用于查询和存入缓存,实现代码如下:

    import org.apache.commons.lang3.StringUtils;
    
    import java.util.concurrent.TimeUnit;
    
    /**
     * 缓存操作工具类
     */
    public class CacheUtils {
    
        /**
         * 添加缓存
         * @param key
         * @param value
         * @param expire
         */
        public void put(String key, Object value, long expire) {
            // 非空判断,借助 commons-lang3
            if (StringUtils.isBlank(key)) return;
            // 当缓存存在时,更新缓存
            if (CacheGlobal.concurrentMap.containsKey(key)) {
                MyCache cache = CacheGlobal.concurrentMap.get(key);
                cache.setHitCount(cache.getHitCount() + 1);
                cache.setWriteTime(System.currentTimeMillis());
                cache.setLastTime(System.currentTimeMillis());
                cache.setExpireTime(expire);
                cache.setValue(value);
                return;
            }
            // 创建缓存
            MyCache cache = new MyCache();
            cache.setKey(key);
            cache.setValue(value);
            cache.setWriteTime(System.currentTimeMillis());
            cache.setLastTime(System.currentTimeMillis());
            cache.setHitCount(1);
            cache.setExpireTime(expire);
            CacheGlobal.concurrentMap.put(key, cache);
        }
    
        /**
         * 获取缓存
         * @param key
         * @return
         */
        public Object get(String key) {
            // 非空判断
            if (StringUtils.isBlank(key)) return null;
            // 字典中不存在
            if (CacheGlobal.concurrentMap.isEmpty()) return null;
            if (!CacheGlobal.concurrentMap.containsKey(key)) return null;
            MyCache cache = CacheGlobal.concurrentMap.get(key);
            if (cache == null) return null;
            // 惰性删除,判断缓存是否过期
            long timoutTime = TimeUnit.NANOSECONDS.toSeconds(
                    System.nanoTime() - cache.getWriteTime());
            // 缓存过期
            if (cache.getExpireTime() <= timoutTime) {
                // 清除过期缓存
                CacheGlobal.concurrentMap.remove(k
                return null;
            }
            cache.setHitCount(cache.getHitCount() + 1);
            cache.setLastTime(System.currentTimeMillis());
            return cache.getValue();
        }
    }
    

    最后是调用缓存的测试代码:

    public class MyCacheTest {
        public static void main(String[] args) {
            CacheUtils cache = new CacheUtils();
            // 存入缓存
            cache.put("key", "老王", 10);
            // 查询缓存
            String val = (String) cache.get("key");
            System.out.println(val);
            // 查询不存在的缓存
            String noval = (String) cache.get("noval");
            System.out.println(noval);
        }
    }
    

    以上程序的执行结果如下:

    老王
    null

    到目前为止,自定义缓存系统就已经实现完了。

    5)小结

    本文讲解了本地缓存和分布式缓存这两个概念和实现的具体方式,其中本地缓存可以通过自己手动编码或借助 Guava Cache 来实现,而分布式缓存可以使用 Redis 或 EhCache 来实现。
    ——————————————————————————————————————————————
    关注公众号,回复 【算法】,获取高清算法书!
    在这里插入图片描述

    展开全文
  • 缓存既然如此重要,那本课时我们就来重点看一下,应该如何实现本地缓存和分布式缓存? 典型回答 本地缓存是指程序级别的缓存组件,它的特点是本地缓存和应用程序会运行在同一个进程中,所以本地
  • 背景 ...本地缓存是指程序级别的缓存组件,它的特点是本地缓存和应用程序会运行在同一个进程中,所以本地缓存的操作会非常快,因为在同一个进程内也意味着不会有网络上的延迟和开销。 本地缓存适用
  • 目录 典型回答 ...以目前的系统架构来说,用户的请求一般会先经过缓存系统,如果缓存中没有相关的数据,就会在其他系统中查询到相应的数据并保存在缓存中,最后返回给调用方。 缓存既然如此重要.
  • 其实这个阶段拿出分布式缓存,有些早,前期主要用的是本地缓存,我使用到的技术主要是ehcahe,这个内存基本就存在你应用运行的服务器上面,这个有个很大的问题就是,不适合长久存储,如果长久存储,数据量很大的时候...
  • 1、首先对于本地内存缓存,就是把数据缓存在本机的内存中,如下图1所示: ...当我们在应用中使用跨进程的缓存机制,例如分布式缓存memcached或者微软的AppFabric,此时数据被缓存在应用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,170
精华内容 468
关键字:

本地缓存和分布式缓存