Java 缓存

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

强引用，软引用，弱引用，虚引用这里就不多说了，百度下就好了。


缓存使用的是softreference。注意需要jvm参数中需要加上

启动时需要加上

-Xms5M -Xmx5M -XX:-UseGCOverheadLimit  -XX:+PrintGCDetails -XX:+PrintReferenceGC  -XX:SoftRefLRUPolicyMSPerMB=0


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

/**
 * -Xms5M -Xmx5M -XX:-UseGCOverheadLimit -XX:SoftRefLRUPolicyMSPerMB=0
 * -XX:SoftRefLRUPolicyMSPerMB=N 这个参数比较有用的，官方解释是：Soft reference在虚拟机中比在客户集中存活的更长一些。
 * 其清除频率可以用命令行参数 -XX:SoftRefLRUPolicyMSPerMB=<N>来控制，这可以指定每兆堆空闲空间的 soft reference 保持
 * 存活（一旦它不强可达了）的毫秒数，这意味着每兆堆中的空闲空间中的 soft reference 会（在最后一个强引用被回收之后）
 * 存活1秒钟。注意，这是一个近似的值，因为  soft reference 只会在垃圾回收时才会被清除，而垃圾回收并不总在发生。
 * 系统默认为一秒，我觉得没必要等1秒，客户集中不用就立刻清除，改为 -XX:SoftRefLRUPolicyMSPerMB=0；
 *   softreference是否回收条件
 *   clock-timestamp >= freespace*SoftRefLRUPolicyMSPerMB
 *   clock：上次gc的时间
 */
public class LRUCache<K,V> {

    private static final Logger LOGGER = LoggerFactory.getLogger(LRUCache.class);

    //数据存储介质，线程安全
    private ConcurrentHashMap<K,V> cache ;
    //保证LRU
    private LRUList lruList;
    //cache中数据的ttl过期时间
    private int ttl;
    //ttl的单位
    private TimeUnit timeUnit;

    //SoftReference软引用的引用队列
    private ReferenceQueue referenceQueue;

    public LRUCache(int maxCapacity){
        this(maxCapacity,7,TimeUnit.DAYS);
    }

    public LRUCache(int maxCapacity, int ttl, TimeUnit timeUnit){
        cache = new ConcurrentHashMap<>();
        lruList = new LRUList(maxCapacity);
        referenceQueue = new ReferenceQueue();
        thread.setDaemon(true);
        thread.start();
        this.ttl = ttl;
        this.timeUnit = timeUnit;
    }

    private class KeyWord<K> extends SoftReference<K> {
        private K value;
        public KeyWord(K referent, ReferenceQueue<? super K> q,K value) {
            super(referent, q);
            this.value = value;
        }
        public K getValue() {
            return value;
        }

        @Override
        protected void finalize() throws Throwable {
            super.finalize();
        }
    }

    public void put(K key,V value){
        if(cache.containsKey(key)){
            synchronized (lruList){
                lruList.put(key,System.currentTimeMillis());
            }
            cache.put(key, value);

        }else{
            synchronized (lruList){
                KeyWord keyWord = new KeyWord(new byte[0],referenceQueue,key);
                lruList.put(key,System.currentTimeMillis());
            }
            cache.put(key,value);
        }
        //内存使用超过80%，通知系统尝试做gc操作
        if(((double)(Runtime.getRuntime().totalMemory()-Runtime.getRuntime().freeMemory())/Runtime.getRuntime().totalMemory())>0.8){
            System.gc();
        }
    }


    public V get(K key){
        V value = cache.get(key);
        if(value!=null){
            Long p =lruList.get(key);
            if(p !=null){
                boolean isDelete = System.currentTimeMillis() - p>timeUnit.toMillis(ttl)?true:false;
                if(isDelete){
                    synchronized (lruList) {
                        lruList.remove(key);
                        cache.remove(key);
                    }
                    LOGGER.info("TTL will remove "+key);
                    return null;
                }
            }
        }
        return value;
    }


    int count = 0 ;
    Thread thread  = new Thread(() -> {
        Object obj = null;
        while(true){
            try {
                obj = referenceQueue.remove();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(obj!=null) {
                synchronized (lruList) {
                    //gc方式移除cache中的数据
                    LOGGER.info(" GC Will remove " + ((KeyWord) obj).getValue());
                    cache.remove(((KeyWord) obj).getValue());
                    lruList.remove(((KeyWord) obj).getValue());
                    count++;
                }
            }
        }
    });

    private class LRUList extends LinkedHashMap<K,Long> {
        private int capacity;
        public LRUList(int capacity){
            super(16, 0.75f, true);
            this.capacity = capacity;
        }
        public LRUList(int initialCapacity, float loadFactor, boolean accessOrder,int capacity) {
            super(initialCapacity, loadFactor, accessOrder);
            this.capacity = capacity;
        }
        public void setCapacity(int capacity){
            this.capacity = capacity;
        }

        @Override
        public Long  put(K key, Long value) {
            return super.put(key, value);
        }

        @Override
        protected boolean removeEldestEntry(Map.Entry<K, Long> eldest) {
            if (size() > capacity) {
                synchronized (lruList) {
                    //cache size 达到capacity lru移除数据
                    LOGGER.info("LRU will remove " + eldest.getKey() +"---"+capacity);
                    cache.remove(eldest.getKey());
                    this.remove(eldest.getKey());
                }
                return true;
            }
            return false;
        }
    }

    public Map<K,V> getCache(){
        return cache;
    }

    public LRUList getLruList(){
        return lruList;
    }


    public int getCount(){
        return count;
    }

}




import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

/**
 * Created by jc6a on 2018/1/25.
 * -Xms5M -Xmx5M -XX:-UseGCOverheadLimit  -XX:+PrintGCDetails -XX:+PrintReferenceGC  -XX:SoftRefLRUPolicyMSPerMB=0
 * -XX:SoftRefLRUPolicyMSPerMB=N 这个参数比较有用的，官方解释是：Soft reference在虚拟机中比在客户集中存活的更长一些。
 * 其清除频率可以用命令行参数 -XX:SoftRefLRUPolicyMSPerMB=<N>来控制，这可以指定每兆堆空闲空间的 soft reference 保持
 * 存活（一旦它不强可达了）的毫秒数，这意味着每兆堆中的空闲空间中的 soft reference 会（在最后一个强引用被回收之后）
 * 存活1秒钟。注意，这是一个近似的值，因为  soft reference 只会在垃圾回收时才会被清除，而垃圾回收并不总在发生。
 * 系统默认为一秒，我觉得没必要等1秒，客户集中不用就立刻清除，改为 -XX:SoftRefLRUPolicyMSPerMB=0；
 * softreference是否回收条件
 *  clock-timestamp >=freespace*SoftRefLRUPolicyMSPerMB
 *  clock上次gc的时间
 *
 */
public class LRUCache<K,V> {

    private static final Logger LOGGER = LoggerFactory.getLogger(LRUCache.class);
    private ConcurrentHashMap<K,V> cache ;
    private LRUList lruList;
    private int ttl;
    private TimeUnit timeUnit;
    private ReferenceQueue referenceQueue;

    public LRUCache(int maxCapacity){
        this(maxCapacity,7,TimeUnit.DAYS);
    }

    public LRUCache(int maxCapacity, int ttl, TimeUnit timeUnit){
        cache = new ConcurrentHashMap<>();
        lruList = new LRUList(maxCapacity);
        referenceQueue = new ReferenceQueue();
        thread.setDaemon(true);
        thread.start();
        this.ttl = ttl;
        this.timeUnit = timeUnit;
    }

    class KeyWord<K> extends SoftReference<K> {
        private K value;
        public KeyWord(K referent, ReferenceQueue<? super K> q,K value) {
            super(referent, q);
            this.value = value;
        }
        public K getValue() {
            return value;
        }

        @Override
        protected void finalize() throws Throwable {
            super.finalize();
        }
    }

    public void put(K key,V value){
        if(cache.containsKey(key)){
            synchronized (lruList){
                lruList.put(key,System.currentTimeMillis());
            }
            cache.put(key, value);

        }else{
            synchronized (lruList){
                KeyWord keyWord = new KeyWord(new byte[0],referenceQueue,key);
                lruList.put(key,System.currentTimeMillis());
            }
            cache.put(key,value);
        }
        if(((double)(Runtime.getRuntime().totalMemory()-Runtime.getRuntime().freeMemory())/Runtime.getRuntime().totalMemory())>0.8){
            System.gc();
        }
    }


    public V get(K key){
        V value = cache.get(key);
        if(value!=null){
            Long p =lruList.get(key);
            if(p !=null){
                boolean isDelete = System.currentTimeMillis() - p>timeUnit.toMillis(ttl)?true:false;
                if(isDelete){
                    synchronized (lruList) {
                        lruList.remove(key);
                        cache.remove(key);
                    }
                    LOGGER.warn("TTL will remove "+key);
                    return null;
                }
            }
        }
        return value;
    }


    int count = 0 ;
    Thread thread  = new Thread(() -> {
        Object obj = null;
        while(true){
            try {
                obj = referenceQueue.remove();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(obj!=null) {
                    synchronized (lruList) {
                        LOGGER.info(" GC Will remove " + ((KeyWord) obj).getValue());
                        cache.remove(((KeyWord) obj).getValue());
                        lruList.remove(((KeyWord) obj).getValue());
                        count++;
                    }
                }
        }
    });

    public class LRUList extends LinkedHashMap<K,Long> {
        private int capacity;
        public LRUList(int capacity){
            super(16, 0.75f, true);
            this.capacity = capacity;
        }
        public LRUList(int initialCapacity, float loadFactor, boolean accessOrder,int capacity) {
            super(initialCapacity, loadFactor, accessOrder);
            this.capacity = capacity;
        }

        @Override
        public Long  put(K key, Long value) {
            return super.put(key, value);
        }

        @Override
        protected boolean removeEldestEntry(Map.Entry<K, Long> eldest) {
            if (size() > capacity) {
                synchronized (lruList) {
                    LOGGER.warn("LRU will remove " + eldest.getKey() +"---"+capacity);
                    cache.remove(eldest.getKey());
                    this.remove(eldest.getKey());
                }
                return true;
            }
            return false;
        }
    }

    public Map<K,V> getCache(){
        return cache;
    }

    public LRUList getLruList(){
        return lruList;
    }


    public int getCount(){
        return count;
    }


    public static void main(String[] args) throws InterruptedException {
        System.out.println(Runtime.getRuntime().totalMemory()/1024/1024);
        LRUCache lruCache = new LRUCache(1000000);
        for(int i=0;i<Integer.MAX_VALUE;i++){
            lruCache.put(String.valueOf("hehehheheehehehehehehe"+i),String.valueOf("hehehheheehehehehehehe"+i));
            System.out.println("huishoule "+lruCache.getCount()+",getCache()"+lruCache.getCache().size()+",i="+i);
        }
        Thread.sleep(Integer.MAX_VALUE);
    }


czj1992czj
关注
专栏目录
java缓存类
07-26
NULL 博文链接：https://j2ee2009.iteye.com/blog/665066
java 缓存机制
06-23
java缓存机制：基于注解的声明式缓存、理解Cache抽象
java中实现缓存的几种方式
shenxiaomo1688的博客
05-16 3161
Redis 是C语言开发的一个开源高性能键值对的内存数据库，可以用来做数据库、缓存、消息中间件等场景，是一种NoSQL(not-only sql,非关系型数据库)的数据库。下面我们介绍在springboot项目中的使用springboot中有redis的starter我们直接引用即可然后在spring配置文件中加入如下设置，这里用的是properties形式的文件，host是部署redis的服务器ip，port是端口号，password是密码，如果没有设置密码不填即可同样我们编写接口测试。
java最强本地缓存-Caffeine
最新发布
学习笔记，相关教程 分享
08-10 780
👏作者简介：我是笑霸final，一名热爱技术的在校学生。
JAVA缓存
kangojian的专栏
01-28 1万+
JAVA缓存有两种: 一、文件缓存,是指把数据存储在磁盘上，可以XML格式，也可以序列化文件DAT格式还是其它文件格式。 二、内存缓存，也就是实现一个类中静态Map,对这个Map进行常规的增删查。其代码如下：目录 [隐藏] 1 Cache类 2 CacheManager类  JAVA缓存-Cache类        public class Cache { private String k
Java缓存机制
热门推荐
losemyfuture的博客
08-21 6万+
1 Java缓存 1.1 jvm内置缓存 Java中实现缓存的方式有很多，比如用static hashMap基于内存缓存的jvm内置缓存，简单不实用，保对象的有效性和周期无法控制，容易造成内存急剧上升。常用的有Oscache（主要针对jsp页面）,Ehcache（主要针对数据库访问层）,Jcache,Jbosscache等等很多 缺点：容易内存溢出、没有持久化（服务重启后丢失）、线程安全、多...
java缓存
清华大咖
09-15 660
一、几种常见的缓存方式 1、java缓存形式/介质 众所周知，缓存之所以访问速度快，是因为把缓存的交互介质是内存。而常规的例如mysql数据交互介质是磁盘。那么常见的java中或者中间件供我们可以用来做缓存的开发的工具有几种呢？ 2、jvm本地内存 jvm本地内存常见使用为定义一个全局静态变量，保证后端服务在运行过程中，对应的对象空间直接保持被引用，不会被GC给回收。 3、guava缓存工具...
缓存、缓存策略、缓存中的问题----面经
weixin_42267615的博客
10-08 372
主要介绍缓存的相关概念，以及缓存策略
Java缓存Map设置过期时间实现解析
08-25
"Java缓存Map设置过期时间实现解析" 本文主要介绍了Java缓存Map设置过期时间实现解析的相关知识点。 1. ExpiringMap功能简介： ExpiringMap是一个Java库，可以设置Map中的Entry在一段时间后自动过期。它提供了多种...
Java缓存池代码实例详解
08-30
这个简单的Java缓存池实例展示了基本的缓存管理机制，包括缓存的创建、存储、检索和过期检查。然而，实际生产环境中，缓存系统可能会更复杂，涉及到并发控制、容量管理、替换策略（如LRU - 最近最少使用）等。例如，...
java缓存数据
03-21
本文将深入探讨“java缓存数据”这一主题，结合提供的标签“源码”和“工具”，我们将从源代码层面和常用工具角度来解析Java缓存的相关知识。 首先，Java缓存数据的基本原理是将频繁访问的数据存储在内存中，避免...
Java缓存技术
10-24
### Java缓存技术详解 #### 一、引言 随着计算机技术的快速发展，Java作为一种流行的编程语言，在多个领域内得到广泛应用。特别是在互联网开发领域，Java因其卓越的通用性、高效性、平台移植性和安全性，成为了不...
Java缓存介绍
weixin_57763462的博客
06-30 953
那么，如果我们在内存中建立一个存储区，将数据缓存起来，当浏览器端由请求到达的时候，直接从内存中获取相应的数据，这样一来可以降低服务器的压力，二来，可以提高请求的响应速度，提升用户体验。缓存是硬件，是CPU中的组件，CPU存取数据的速度非常的快，一秒钟能够存取、处理十亿条指令和数据（术语：CPU主频1G），而内存就慢很多，快的内存能够达到几十兆就不错了，可见两者的速度差异是多么的大 ，缓存是为了解决CPU和内存两者速度差异问题的中间媒体，将CPU访问频率较高的数据从内存读入缓存，从而提高软件执行效率。
Java本地缓存
清雨小竹
06-21 5333
Guava Cache是Guava提供的一个本地缓存框架，它使用LRU算法来管理缓存。Java实现本地缓存的方式有很多，其中比较常见的有HashMap、Guava Cache、Caffeine和Encahche等。Caffeine:Caffeine是一个高性能的Java本地缓存库，它使用了基于时间戳的过期策略和可扩展性设计。Encahche:Encahche是一个轻量级的Java本地缓存库，它使用了基于时间戳的过期策略和可扩展性设计。优点是简单粗暴，不需要引入第三方包，比较适合一些比较简单的场景。
Java缓存
zzypiper的博客
05-30 166
Java缓存１ 概念1.1 什么是缓存1.2 为什么要用缓存2 Java内存缓存2.1 场景2.2 ConcurrentHashMap实现缓存3 Guava3.1 介绍3.2 适用场景3.3 简单使用 １ 概念 1.1 什么是缓存 在计算中，缓存是一个高速数据存储层，其中存储了数据子集，且通常是短暂性存储。缓存的访问速度比主存的访问速度快，可以高效地重用之前检索或者计算的数据。 也就是把数据从访问慢的介质挪到访问快的介质。 1.2 为什么要用缓存 提升应用程序性能 降低数据库成本 减少后端负载 可预测性能
缓存机制详解
weixin_30580943的博客
03-07 104
转载自：http://blog.sina.com.cn/jieruicj 缓存机制详解一． 为什么要使用缓存如果每次进入页面的时候都查询数据库生成页面内容的话，如果访问量非常大，则网站性能会非常差。而如果只有第一次访问的时候才查询数据库生成页面内容，以后都直接输出内容，则能提高系统性能。这样无论有多少人访问都只访问一次数据库，数据库压力不变。二． 什么是缓存：缓存(Cache)是一种用空间换取时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值