首页 / 缓存 / Java使用ConcurrentHashMap实现简单的内存式缓存

Java使用ConcurrentHashMap实现简单的内存式缓存

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Java使用ConcurrentHashMap实现简单的内存式缓存，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含6322字，纯文字阅读大概需要10分钟。

内容图文

需求说明：

实际项目中我打算把用户和组织信息放到缓存中，基于此提出以下几点需求：

1.数据存储在内存中；
2.允许以键值对的方式存储对象类数据并带有过期策略；
3.不限制内存使用，单cache也不能给我报出OutOfMemoryErrormemory异常；
4.cache要自动清理过期对象
5.线程安全

为了满足以上需求，本例子中主要使用了以下技术：
1.ConcurrentHashMap
2.DelayQueue
3.SoftReference
4.Thread

5.java8的Optional及函数式编程

这里提供2中编码实现，先定义一个接口，用于规范和统一方法：

package com.dylan.springboot.helloweb.cache;

/**
 * @Description: 自定义缓存接口
 * @Author laoxu
 * @Date 2019/7/27 13:45
 **/
public interface ICache {
    void add(String key, Object value, long periodInMillis);

    void remove(String key);

    Object get(String key);

    void clear();

    long size();

}

方案1：

package com.dylan.springboot.helloweb.cache;

/**
 * @Description: 带过期时间的缓存对象
 * @Author laoxu
 * @Date 2019/7/27 14:27
 **/
public class CacheObject {
    private Object value;
    private long expiryTime;

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

    public Object getValue() {
        return value;
    }

    boolean isExpired() {
        return System.currentTimeMillis() > expiryTime;
    }


}

package com.dylan.springboot.helloweb.cache;


import java.lang.ref.SoftReference;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @Description: 方案1，缓存实现
 * @Author laoxu
 * @Date 2019/7/27 13:47
 **/
// @Component
public class CacheImpl implements ICache {
    private static final int CLEAN_UP_PERIOD_IN_SEC = 5;

    private final ConcurrentHashMap<String, SoftReference<CacheObject>> cache = new ConcurrentHashMap<>();

    public CacheImpl() {
        Thread cleanerThread = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    Thread.sleep(CLEAN_UP_PERIOD_IN_SEC * 1000);
                    cache.entrySet().removeIf(entry -> Optional.ofNullable(entry.getValue()).map(SoftReference::get).map(CacheObject::isExpired).orElse(false));
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });
        cleanerThread.setDaemon(true);
        cleanerThread.start();
    }

    @Override
    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)));
        }
    }

    @Override
    public void remove(String key) {
        cache.remove(key);
    }

    @Override
    public Object get(String key) {
        return Optional.ofNullable(cache.get(key)).map(SoftReference::get).filter(cacheObject -> !cacheObject.isExpired()).map(CacheObject::getValue).orElse(null);
    }

    @Override
    public void clear() {
        cache.clear();
    }

    @Override
    public long size() {
        return cache.entrySet().stream().filter(entry -> Optional.ofNullable(entry.getValue()).map(SoftReference::get).map(cacheObject -> !cacheObject.isExpired()).orElse(false)).count();
    }



}

此方案有2大缺陷：

1.如果map中存储了大量的对象那么扫描这些对象并清理需要花不少时间；
2.此处的size()方法将花费O(n)时间因为它必须过滤掉过期对象。

方案2（推荐）：

package com.dylan.springboot.helloweb.cache;

import java.lang.ref.SoftReference;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

/**
 * @Description: 带key和过期时间的缓存对象
 * @Author laoxu
 * @Date 2019/7/27 15:28
 **/
public class DelayedCacheObject implements Delayed {
    private final String key;
    private final SoftReference<Object> reference;
    private final long expiryTime;

    public DelayedCacheObject(String key, SoftReference<Object> reference, long expiryTime) {
        this.key = key;
        this.reference = reference;
        this.expiryTime = expiryTime;
    }

    public String getKey() {
        return key;
    }

    public SoftReference<Object> getReference() {
        return reference;
    }

    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(expiryTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
    }

    @Override
    public int compareTo(Delayed o) {
        return Long.compare(expiryTime, ((DelayedCacheObject) o).expiryTime);
    }
}

package com.dylan.springboot.helloweb.cache;

import org.springframework.stereotype.Component;

import java.lang.ref.SoftReference;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.DelayQueue;

/**
 * @Description: 方案2，缓存实现
 * @Author laoxu
 * @Date 2019/7/27 15:24
 **/
@Component
public class InMemoryCacheWithDelayQueue implements ICache {
    private final ConcurrentHashMap<String, SoftReference<Object>> cache = new ConcurrentHashMap<>();
    private final DelayQueue<DelayedCacheObject> cleaningUpQueue = new DelayQueue<>();

    public InMemoryCacheWithDelayQueue() {
        Thread cleanerThread = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    DelayedCacheObject delayedCacheObject = cleaningUpQueue.take();
                    cache.remove(delayedCacheObject.getKey(), delayedCacheObject.getReference());
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });
        cleanerThread.setDaemon(true);
        cleanerThread.start();
    }

    @Override
    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;
            SoftReference<Object> reference = new SoftReference<>(value);
            cache.put(key, reference);
            cleaningUpQueue.put(new DelayedCacheObject(key, reference, expiryTime));
        }
    }

    @Override
    public void remove(String key) {
        cache.remove(key);
    }

    @Override
    public Object get(String key) {
        return Optional.ofNullable(cache.get(key)).map(SoftReference::get).orElse(null);
    }

    @Override
    public void clear() {
        cache.clear();
    }

    @Override
    public long size() {
        return cache.size();
    }

}

测试

为了方便测试，我在spring boot中添加了controller：

package com.dylan.springboot.helloweb.controller;

import com.dylan.springboot.helloweb.cache.ICache;
import com.dylan.springboot.helloweb.entity.Student;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * @Description: 测试缓存
 * @Author laoxu
 * @Date 2019/7/27 14:35
 **/
@RestController
@RequestMapping("/cache")
public class CacheController {

    @Autowired
    private ICache cache;

    @GetMapping("/size")
    public Long getSize(){
        return cache.size();
    }

    @PostMapping("/add")
    public String add(@RequestBody Student student){
        cache.add(student.getName(),student,60000);

        return "success";
    }

    @GetMapping("/get")
    public Student get(String name){
        Student student = (Student) cache.get(name);

        return student;
    }



}

内容总结

以上是互联网集市为您收集整理的Java使用ConcurrentHashMap实现简单的内存式缓存全部内容，希望文章能够帮你解决Java使用ConcurrentHashMap实现简单的内存式缓存所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/960033.html

来源：【匿名】

【上一篇】在Linux中实际检测缓存未命中和命中【下一篇】屏蔽浏览器缓存另类方法

更多 ►

【Java使用ConcurrentHashMap实现简单的内存式缓存】教程文章相关的互联网学习教程文章

hash 哈希表缓存表

系统初始hash表为空，当外部命令执行时，默认会从 PATH路径下寻找该命令，找到后会将这条命令的路径记录到 hash表中，当再次使用该命令时，shell解释器首先会查看hash 表，存在将执行之，如果不存在，将会去PATH路径下寻找。利用hash缓存表可大大提高命令的调用速率。一般格式：hash [选项]　　 -l：列出表中内容　　 -p PATH NAME ：给命令建立缓存　　 -d 命令：删除命令的缓存　　 -t 命令：列出单个别名的路径　　 -r ：清空...

InnoDB的关键特性-插入缓存,两次写,自适应hash索引详解【图】

InnoDB存储引擎的关键特性包括插入缓冲、两次写（double write）、自适应哈希索引（adaptive hash index）。这些特性为InnoDB存储引擎带来了更好的性能和更高的可靠性。插入缓冲插入缓冲是InnoDB存储引擎关键特性中最令人激动的。不过，这个名字可能会让人认为插入缓冲是缓冲池中的一个部分。其实不然，InnoDB缓冲池中有Insert Buffer信息固然不错，但是Insert Buffer和数据页一样，也是物理页的一个组成部分。主键是行唯一的标...

【InnoDB】插入缓存，两次写，自适应hash索引【代码】【图】

doublewrite一共写了18 445个页，但实际的写入次数为434，(42:1) 基本上符合64:1。如果发现你的系统在高峰时Innodb_dblwr_pages_written:Innodb_dblwr_writes远小于64:1，那么说明你的系统写入压力并不是很高。如果操作系统在将页写入磁盘的过程中崩溃了，在恢复过程中，InnoDB存储引擎可以从共享表空间中的doublewrite中找到改页的一个副本，将其拷贝到表空间文件，再应用重做日志。下面显示了由doublewrite进行恢复的一种情况...

redis缓存数据库Hash,list,set操作【代码】【图】

Hash操作 hash表现形式上有些像python中的dict，可以存储一组关联性较强的数据，redis中Hash在内存中的存储格式如下图:1、hset(name,key,value)#name对应的hash中设置一个键值对(不存在，则创建；否则，修改)#参数：#name,redis的name#key,name对应的hash中的key#vale,name对应的Hash中的value#如：127.0.0.1:6379> hset fle1 k1 2(integer) 1 2、hmset(name,mapping)#在name对应的Hash中批量设置键值对#参数：#name,redis的name#m...

Redis分布式缓存系列（三）- Redis中的Hash类型【代码】【图】

本系列将和大家分享Redis分布式缓存，本章主要简单介绍下Redis中的Hash类型。散列Hash：类似dictionary，通过索引快速定位到指定元素的，耗时均等，跟string的区别在于不用反序列化，直接修改某个字段。存储形式： hashId-{key:value;key:value;key:value;}在正式开始介绍Hash类型之前，我们先来思考一个问题，如何使用我们上一篇介绍的String类型来缓存和修改一个学生对象信息。大家能想到的可能有以下两种方案：方案1：查询-反...

分布式项目中如何用redis做缓存（二）——redis的String和hash数据类型【图】

redis的String和hash数据类型一、String数据类型 String：key-value（做缓存） Redis 中所有的数据都是字符串。命令不区分大小写，key 是区分大小写的。 Redis 是单线程的。Redis 中不适合保存内容大的数据。数据的操作set:添加 get：获取 del：删除 key*：查询所有key incr：自动加一（int型） decr：自动减一（int型） *：通配符二、hash数据类型 Hash：key-fields-values（做缓存）相当于一个 key 对应一个 map，map 中还有...

redis关于hash类型存储关系型数据商品展示（redis缓存） redis之路（三）【代码】

对于redis来说key必须是Stringl类型的，他们的value类似hashMaphash叫散列类型，它提供了字段和字段值的映射。**redis hash存储比关系数据库的好处？**两者都可以存放对象，对于关系型数据库来说，存储数据比较严格，有事务控制，安全性高。但是关系型数据库在并发压力下性能很低，所以使用redis hash类型可以在一定程序上替代关系型数据库，因为redis单机并发量支持10w+常见命令： **设值，取值**127.0.0.1:6380> hset user:1 use...

分方式缓存常用的一致性hash是什么原理【图】

一致性hash是用来解决什么问题的？先看一个场景有n个cache服务器，一个对象object映射到哪个cache上呢？可以采用通用方法计算object的hash值，然后均匀的映射到到n个cachehash(object) % n初始阶段运行正常，但当cache服务器发生变动后就会出现问题例如（1）一个cache服务器down掉了，这样所有映射到此cache的对象都会失效，需要把此cache移除，这时候映射公式变成了 hash(object) % (n-1) （2）由于访问加重，需要添加cache ，这时...

缓存 - 最热教程

微信小程序如何修改本地缓存key中单个数...Yii清理缓存的方法_PHP .Net 性能优化--缓存--分布式缓存 --sq...SQL Server 缓存清除与内存释放详解微信小程序缓存--缓存时效性 Ajax清除浏览器js、css、图片缓存的方法 node.js利用redis数据库缓存数据 Apache缓存相关配置_PHP教程 [apicloud缓存和数据库同步]APICloud 获...Java servlet如何禁用页面缓存

首页 / 缓存 / Java使用ConcurrentHashMap实现简单的内存式缓存

Java使用ConcurrentHashMap实现简单的内存式缓存

内容导读

内容图文

需求说明：

方案1：

方案2（推荐）：

测试

内容总结

内容备注

内容手机端

【Java使用ConcurrentHashMap实现简单的内存式缓存】教程文章相关的互联网学习教程文章

hash 哈希表缓存表

InnoDB的关键特性-插入缓存,两次写,自适应hash索引详解【图】

【InnoDB】插入缓存，两次写，自适应hash索引【代码】【图】

redis缓存数据库Hash,list,set操作【代码】【图】

Redis分布式缓存系列（三）- Redis中的Hash类型【代码】【图】

分布式项目中如何用redis做缓存（二）——redis的String和hash数据类型【图】

redis关于hash类型存储关系型数据商品展示（redis缓存） redis之路（三）【代码】

分方式缓存常用的一致性hash是什么原理【图】

JAVA - 相关标签

缓存 - 相关标签

内存 - 相关标签

缓存 - 最新教程

缓存 - 最热教程