Java缓存

最新推荐文章于 2024-06-17 08:50:02 发布
最新推荐文章于 2024-06-17 08:50:02 发布
阅读量158 收藏
点赞数
分类专栏： 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzypiper/article/details/106437991
版权

Java缓存

１ 概念

1.1 什么是缓存

在计算中，缓存是一个高速数据存储层，其中存储了数据子集，且通常是短暂性存储。缓存的访问速度比主存的访问速度快，可以高效地重用之前检索或者计算的数据。

也就是把数据从访问慢的介质挪到访问快的介质。

1.2 为什么要用缓存

  1. 提升应用程序性能
  2. 降低数据库成本
  3. 减少后端负载
  4. 可预测性能
  5. 消除数据库热点
  6. 提高读取吞吐量（IOPS）

2 Java内存缓存

2.1 场景

在Java应用中，对于访问频率高，更新少的数据，通常的方案是将这些数据加入到缓存中。相对于从数据库中读取，使用缓存在效率上有很大的提升。

在集群环境下，通常的分布式缓存有Redis、Memcached等。但在某些业务场景中，可能不需要搭建一套复杂的分布式缓存系统，在单机环境下，通常是会希望使用内部缓存（LocalCache）。

2.2 ConcurrentHashMap实现缓存

MapCache

public class MapCache {
    /**
     * 定时5秒一次清理过期缓存
     */
    private static final int CLEAN_UP_PERIOD_IN_SEC = 5;
    /**
     * 软引用保证在跑出OutOfMemory之前，如果缺少内存，gc会清理引用的对象
     */
    private final ConcurrentHashMap<String, SoftReference<CacheObject>> cache = new ConcurrentHashMap<>();


    public MapCache() {
        /**
         * 守护线程，定期去除过期数据
         */
        Thread cleanerThread = new Thread(() -> {
            String key;
            SoftReference<CacheObject> softRef;
            while (!Thread.currentThread().isInterrupted()){
                try {
                    Thread.sleep(CLEAN_UP_PERIOD_IN_SEC * 1000);
                    for (Map.Entry<String, SoftReference<CacheObject>> entry : cache.entrySet()){
                        key = entry.getKey();
                        softRef = entry.getValue();
                        if (softRef.get() == null || softRef.get().isExpired()){
                            cache.remove(key);
                        }
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });
        cleanerThread.setDaemon(true);
        cleanerThread.start();
    }

    /**
     * 添加键值对
     *
     * @param key
     * @param value
     * @param periodInMillis
     */
    public void add(String key, Object value, long periodInMillis) {
        if (key == null) {
            return;
        }
        if (value == null) {
            cache.remove(key);
        } else {
            long expiryTime = System.currentTimeMillis() + periodInMillis;
            cache.put(key, new SoftReference<>(new CacheObject(value, expiryTime)));
        }
    }

    /**
     * 删除键值对
     *
     * @param key
     */
    public void remove(String key) {
        cache.remove(key);
    }

    /**
     * 获取值
     *
     * @param key
     * @return
     */
    public Object get(String key) {
        if (cache.containsKey(key)) {
            return cache.get(key).get().getValue();
        }
        return null;
    }

    /**
     * 清空缓存
     */
    public void clear() {
        cache.clear();
    }

    /**
     * 获取大小
     *
     * @return
     */
    public long size() {
        return cache.size();
    }


    /**
     * 缓存对象value
     */
    private static class CacheObject {
        private Object value;
        private long expiryTime;

        private CacheObject(Object value, long expiryTime) {
            this.value = value;
            this.expiryTime = expiryTime;
        }

        /**
         * 是否过期
         * @return
         */
        boolean isExpired() {
            return System.currentTimeMillis() > expiryTime;
        }

        public Object getValue() {
            return value;
        }

        public void setValue(Object value) {
            this.value = value;
        }
    }
}

pojo

public class User implements Serializable {
    private String userName;
    private String userId;

    public User(String userName, String userId) {
        this.userName = userName;
        this.userId = userId;
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    @Override
    public String toString() {
        return userId + " --- " + userName;
    }
}

test

    @Test
    public void test() throws InterruptedException {
        MapCache cache = new MapCache();
        cache.add("uid_10001", new User("张三","uid_10001"), 5 * 1000);
        cache.add("uid_10002", new User("李四","uid_10002"), 5 * 1000);
        cache.add("uid_10003", new User("王五","uid_10003"), 5 * 1000);
        System.out.println("从缓存中取出值:" + cache.get("uid_10001").toString());
        System.out.println("从缓存中取出值:" + cache.get("uid_10002").toString());
        System.out.println("从缓存中取出值:" + cache.get("uid_10003").toString());
        Thread.sleep(6000L);
        System.out.println("6秒钟过后");
        System.out.println("从缓存中取出值:" + cache.get("uid_10001").toString());
        System.out.println("从缓存中取出值:" + cache.get("uid_10002").toString());
        System.out.println("从缓存中取出值:" + cache.get("uid_10003").toString());
    }

3 Guava

3.1 介绍

Guava Cache是google guava中的一个内存缓存模块，用于讲数据缓存到JVM内存中。实际项目开发中经常将一些公共后者常用的数据缓存起来方便快速访问。

3.2 适用场景

  • 愿意消耗一些内存空间来提升速度
  • 预料到某些建会被查询一次以上
  • 缓存中存放的数据总量不会超出内存容量

Guava Cache是单个应用运行时的本地缓存，它不会把数据存放到文件或者外部服务器。其他场景可使用Redis、Memcached这类工具。

3.3 简单使用

public class GuavaCacheDemo {

    public static void main(String[] args) throws ExecutionException {
        LoadingCache<String, User> cache = CacheBuilder.newBuilder()
                // 设置并发级别为8，并发级别是指可以同时写缓存的线程数
                .concurrencyLevel(8)
                // 设置缓存容器的初始容量为10
                .initialCapacity(10)
                // 设置缓存的最大容量为100，超过100之后按照LRU最近最少使用算法来移除缓存
                .maximumSize(100)
                // 是否需要统计缓存情况，该操作消耗一定的性能，生产环境应该去除
                .recordStats()
                // 设置写缓存后n秒钟过期
                .expireAfterWrite(17, TimeUnit.SECONDS)
                // 设置读写缓存后n秒钟过期,实际很少用到,类似于expireAfterWrite
                //.expireAfterAccess(17, TimeUnit.SECONDS)
                //只阻塞当前数据加载线程，其他线程返回旧值
                //.refreshAfterWrite(13, TimeUnit.SECONDS)

                //设置缓存的移除通知
                .removalListener(removalNotification -> {
                    System.out.println(removalNotification.getKey() + " " + removalNotification.getValue() + " 被移除,原因:" + removalNotification.getCause());
                })
                //build方法中可以指定CacheLoader，在缓存不存在时通过CacheLoader的实现自动加载缓存
                .build(new MyCacheLoader());
        // 第一次查询
        for (int i = 0; i < 10; i++) {
            System.out.println(cache.get("uid_1000" + i).toString());
        }

        // 第二次查询
        for (int i = 0; i < 10; i++) {
            System.out.println(cache.get("uid_1000" + i).toString());
        }

		// 打印统计信息
        System.out.println(cache.stats().toString());

    }


    /**
     * 实际使用时应实现业务的缓存加载逻辑，例如从数据库中获取数据
     */
    public static class MyCacheLoader extends CacheLoader<String, User> {

        @Override
        public User load(String s) throws Exception {
            System.out.println(Thread.currentThread().getName() + " 加载数据开始");
            // 假设从数据库加载数据
            TimeUnit.SECONDS.sleep(1);
            Random random = new Random();
            User user = new User(s, "zzy" + random.nextInt(1000));
            System.out.println(Thread.currentThread().getName() + " 加载数据结束");
            return user;
        }
    }
}

输出

main 加载数据开始
main 加载数据结束
uid_10000 --- zzy841
main 加载数据开始
main 加载数据结束
uid_10001 --- zzy211
main 加载数据开始
main 加载数据结束
uid_10002 --- zzy346
main 加载数据开始
main 加载数据结束
uid_10003 --- zzy768
main 加载数据开始
main 加载数据结束
uid_10004 --- zzy955
main 加载数据开始
main 加载数据结束
uid_10005 --- zzy585
main 加载数据开始
main 加载数据结束
uid_10006 --- zzy132
main 加载数据开始
main 加载数据结束
uid_10007 --- zzy664
main 加载数据开始
main 加载数据结束
uid_10008 --- zzy212
main 加载数据开始
main 加载数据结束
uid_10009 --- zzy234
uid_10000 --- zzy841
uid_10001 --- zzy211
uid_10002 --- zzy346
uid_10003 --- zzy768
uid_10004 --- zzy955
uid_10005 --- zzy585
uid_10006 --- zzy132
uid_10007 --- zzy664
uid_10008 --- zzy212
uid_10009 --- zzy234
CacheStats{hitCount=10, missCount=10, loadSuccessCount=10, loadExceptionCount=0, totalLoadTime=10005123400, evictionCount=0}
zzypiper
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 缓存机制
06-23
java缓存机制：基于注解的声明式缓存、理解Cache抽象
Java缓存技术
10-24
### Java缓存技术详解 #### 一、引言 随着计算机技术的快速发展，Java作为一种流行的编程语言，在多个领域内得到广泛应用。特别是在互联网开发领域，Java因其卓越的通用性、高效性、平台移植性和安全性，成为了不...
JAVA缓存
kangojian的专栏
01-28 1万+
JAVA缓存有两种: 一、文件缓存,是指把数据存储在磁盘上，可以XML格式，也可以序列化文件DAT格式还是其它文件格式。 二、内存缓存，也就是实现一个类中静态Map,对这个Map进行常规的增删查。其代码如下：目录 [隐藏] 1 Cache类 2 CacheManager类  JAVA缓存-Cache类        public class Cache { private String k
Java一分钟之-Ehcache：分布式缓存系统
最新发布
zevjay的博客
06-17 923
Ehcache 3.x版本开始支持基于Terracotta的分布式缓存，允许数据跨多个节点共享，提供了数据冗余、故障转移和水平扩展的能力。分区：数据自动分布在集群各节点上，实现负载均衡。复制：支持多种复制策略，保证数据的一致性。容错：节点失败时，数据可以从其他节点恢复。动态配置：无需重启即可调整缓存配置。
Java缓存机制
热门推荐
losemyfuture的博客
08-21 6万+
1 Java缓存 1.1 jvm内置缓存 Java中实现缓存的方式有很多，比如用static hashMap基于内存缓存的jvm内置缓存，简单不实用，保对象的有效性和周期无法控制，容易造成内存急剧上升。常用的有Oscache（主要针对jsp页面）,Ehcache（主要针对数据库访问层）,Jcache,Jbosscache等等很多 缺点：容易内存溢出、没有持久化（服务重启后丢失）、线程安全、多...
关于java中的本地缓存-总结概述
iamzhongyong的专栏
03-31 1103
java中的本地缓存，工作后陆续用到,一直想写，一直无从下手，最近又涉及到这方面的问题了，梳理了一下。自己构造单例、guava、ehcache基本上涵盖了目前的大多数行为了。   为什么要有本地缓存？ 在系统中，有些数据，数据量小，但是访问十分频繁（例如国家标准行政区域数据），针对这种场景，需要将数据搞到应用的本地缓存中，以提升系统的访问效率，减少无谓的数据库访问（数据库访问占用数据库连...
java缓存
liu372267001的专栏
08-05 810
1. 缓存为什么要存在? 一般情况下,一个网站,或者一个应用,它的一般形式是,浏览器请求应用服务器,应用服务器做一堆计算后再请求数据库,数据库收到请求后再作一堆计算后把数据返回给应用服务器,应用服务器再作一堆计算后把数据返回给浏览器.这个是一个标准流程.但是随着互连网的普及,
Java缓存Map设置过期时间实现解析
08-25
"Java缓存Map设置过期时间实现解析" 本文主要介绍了Java缓存Map设置过期时间实现解析的相关知识点。 1. ExpiringMap功能简介： ExpiringMap是一个Java库，可以设置Map中的Entry在一段时间后自动过期。它提供了多种...
java缓存技术
09-14
下面我们将深入探讨Java缓存技术，特别是Ehcache的使用。 首先，理解缓存的基本原理至关重要。缓存是一种存储技术，用于临时存储最近或最常访问的数据，以便快速访问。在Java应用中，缓存可以减少对远程服务（如...
java缓存工具 SimpleCache_java_缓存_
10-04
Java 缓存工具 SimpleCache 是一个用于在 Java 应用程序中实现高效数据存储和检索的框架。在高并发和大数据量的场景下，缓存是提高系统性能的关键技术之一。SimpleCache 提供了一种简洁的方式来管理短期数据，避免了...
spleen:Java缓存库
05-25
脾Java缓存库Spleen是用Java编写的存储缓存库，它允许存储内存大小限制以及每个存储数据的超时限制。 脾脏提供两种存储类型，即使用简单线程或多线程删除的观察者。 简单的名称空间启动一个单独的线程来检查要删除的...
Java中常用缓存Cache机制的实现
09-01
主要介绍了Java中常用缓存Cache机制的实现代码,具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Java 中常用缓存Cache机制的实现
11-08
Java 中常用缓存Cache机制的实现
缓存、缓存策略、缓存中的问题----面经
weixin_42267615的博客
10-08 291
主要介绍缓存的相关概念，以及缓存策略
Java 缓存
Biu Biu Biu ~~~~~
05-25 316
强引用，软引用，弱引用，虚引用这里就不多说了，百度下就好了。缓存使用的是softreference。注意需要jvm参数中需要加上启动时需要加上-Xms5M -Xmx5M -XX:-UseGCOverheadLimit -XX:+PrintGCDetails -XX:+PrintReferenceGC -XX:SoftRefLRUPolicyMSPerMB=0import org.slf4j.L...
java ismp_Java 中常用缓存Cache机制的实现
weixin_42519826的博客
02-13 148
所谓缓存，就是将程序或系统经常要调用的对象存在内存中，一遍其使用时可以快速调用，不必再去创建新的重复的实例。这样做可以减少系统开销，提高系统效率。所谓缓存，就是将程序或系统经常要调用的对象存在内存中，一遍其使用时可以快速调用，不必再去创建新的重复的实例。这样做可以减少系统开销，提高系统效率。缓存主要可分为二大类:一、通过文件缓存,顾名思义文件缓存是指把数据存储在磁盘上，不管你是以XML格式，序列化...
缓存机制详解
weixin_30580943的博客
03-07 102
转载自：http://blog.sina.com.cn/jieruicj 缓存机制详解一． 为什么要使用缓存如果每次进入页面的时候都查询数据库生成页面内容的话，如果访问量非常大，则网站性能会非常差。而如果只有第一次访问的时候才查询数据库生成页面内容，以后都直接输出内容，则能提高系统性能。这样无论有多少人访问都只访问一次数据库，数据库压力不变。二． 什么是缓存：缓存(Cache)是一种用空间换取时...
Java缓存技术解析：Cache与CacheManager
"Java缓存应用涉及到两种主要的缓存方式：文件缓存和内存缓存。文件缓存通常将数据存储在磁盘上，可以是XML、序列化文件或其他格式。而内存缓存则是通过在类中创建一个静态Map来实现，用于快速访问和操作数据。本文...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值