Java 缓存技术中的缓存懒加载

王林

发布时间：2023-06-20 12:24:10

1721人浏览过

来源于php中文网

原创

java 缓存技术中的缓存懒加载

在 Java 圈子中，缓存技术是非常常见的一种技术。缓存的作用就是为了提高数据访问的性能，避免重复计算和重复请求。缓存技术的应用场景非常广泛，特别是在一些需要频繁访问数据的应用中，如电商网站、新闻门户、社交应用等等。

然而，缓存技术也有一些缺点，例如：缓存的初始化和更新可能会消耗大量的时间和性能资源。因此，为了提高缓存的性能和效率，有一种称为“缓存懒加载”的技术应运而生，它可以有效地解决缓存初始化和更新的问题，从而提高系统的性能和效率。

什么是缓存懒加载？

缓存懒加载，就是指延迟初始化缓存数据，等待第一次访问时再加载数据到缓存中。这种技术的优点是可以避免不必要的初始化和更新操作，从而降低系统的开销和资源消耗。当然，缓存懒加载的缺点是第一次访问时可能会造成一些延迟，但是在大多数应用场景中，这种延迟是可以被接受的。因此，缓存懒加载技术在很多应用中都是非常常用的技术。

立即学习“Java免费学习笔记（深入）”；

缓存懒加载的实现方式

在 Java 中，缓存懒加载的实现方式有很多种，这里我们介绍几种常见的实现方式。

方式一：使用 ConcurrentHashMap 和 Future 实现

ConcurrentHashMap 是 JDK 1.5 引入的线程安全的哈希表，可以用来存储缓存数据，而 Future 则可以用来异步加载数据。

具体实现方式如下：

public class MyCache {
    private final Map> cache = new ConcurrentHashMap<>();
    private final Function loadDataFunction;

    public MyCache(Function loadDataFunction) {
        this.loadDataFunction = loadDataFunction;
    }

    public String getData(String key) throws ExecutionException, InterruptedException {
        Future future = cache.get(key);

        if (future == null) {
            Callable callable = () -> loadDataFunction.apply(key);
            FutureTask futureTask = new FutureTask<>(callable);
            future = cache.putIfAbsent(key, futureTask);  
            if (future == null) {
                future = futureTask;
                futureTask.run();
            }
        }
        return future.get();
    }
}

这个实现方式比较简单，大概的流程如下：

尝试从缓存中获取指定 key 的 Future 值；
如果 Future 值为 null，说明对应的数据没有被缓存，则通过 loadDataFunction 加载数据，并将其封装成 FutureTask 对象，插入到缓存中；
如果插入成功（即之前没有其他线程插入过该 key），则运行 FutureTask 以异步加载数据；
最后，返回缓存中指定 key 对应的 Future 值。

方式二：使用 Double-Checked Locking 实现

网奇.NET网络商城系统

系统优势： 1、使用全新ASP.Net＋c#和三层结构开发. 2、可生成各类静态页面（html,htm,shtm,shtml和.aspx) 3、管理后台风格模板自由选择，界面精美 4、风格模板每月更新多套，还可按需定制 5、独具的缓存技术加快网页浏览速度 6、智能销售统计，图表分析 7、集成国内各大统计系统 8、多国语言支持，内置简体繁体和英语 9、 UTF-8编码，可使用于全球

下载

Double-Checked Locking 是一种常见的多线程编程技巧，可以避免重复的锁竞争，从而提高系统性能。在缓存懒加载中，可以使用 Double-Checked Locking 技巧来实现延迟初始化的效果。

具体实现方式如下：

public class MyCache {
    private Map cache = null;

    public String getData(String key) {
        String data = cache.get(key);
        if (data == null) {
            synchronized (this) {
                data = cache.get(key);

                if (data == null) {
                    data = loadData(key);
                    cache.put(key, data);
                }
            }
        }
        return data;
    }

    private String loadData(String key) {
        // TODO: load data from database or remote API
        return "data";
    }
}

这个实现方式比较简单，大概的流程如下：

尝试从缓存中获取指定 key 的值；
如果值为 null，则执行 synchronized 代码块；
在 synchronized 代码块中，再次尝试获取缓存数据，如果依然为 null，则调用 loadData 方法加载数据，并将其存储到缓存中；
最后，返回指定 key 对应的数据。

方式三：使用 AtomicReference 实现

AtomicReference 是 JDK 1.5 引入的原子操作类，可以用来实现缓存懒加载的效果。

具体实现方式如下：

public class MyCache {
    private final Map cache = new ConcurrentHashMap<>();
    private final AtomicReference> reference =
            new AtomicReference<>(null);

    public String getData(String key) {
        Map currentCache = reference.get();

        if (currentCache == null) {
            currentCache = cache;
            reference.compareAndSet(null, currentCache);
        }

        return currentCache.computeIfAbsent(key, k -> loadData(k));
    }

    private String loadData(String key) {
        // TODO: load data from database or remote API
        return "data";
    }
}

这个实现方式比较复杂，大概的流程如下：