「javamap缓存」map实现缓存
本篇文章给大家谈谈javamap缓存，以及map实现缓存对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
- 1、请教java中怎么缓存大量的数据，比如100w条记录
- 2、java中map可否限制key的数量
- 3、Map实现带失效时间的缓存工具类
- 4、java怎样将数据保存到缓存中，之后再保存
- 5、java map可以放多少数据
- 6、java怎么实现map 缓存技术
请教java中怎么缓存大量的数据，比如100w条记录
通常Java的缓存都是用HashMap，数据大的话，占用内存就大，所以JVM虚拟机在启动的时候要把内存设置大点，否则会内存溢出。
Java学习交流！
java中map可否限制key的数量
在JDK中提供了一个相当用价值的主要用于缓存的Map实现—— LinkedHashMap 。
LinkedHashMap的迭代顺序就是最后访问其条目的顺序，从近期访问最少到近期访问最多的顺序。
详情可参考JKD中关于LinkedHashMap 的API文档。
你需要做的就是继承LinkedHashMap 并重写removeEldestEntry方法。
示例如下：
private static final int MAX_ENTRIES = 100;
protected boolean removeEldestEntry(Map.EntryK,V eldest) {
// 当前记录数大于设置的最大的记录数，删除最旧记录（即最近访问最少的记录）
return size() MAX_ENTRIES;
}
Map实现带失效时间的缓存工具类
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
public class CacheWithExpireUtil {
// 缓存map
private static MapcacheMap =new ConcurrentHashMap();
// 缓存有效期map
private static MapexpireTimeMap =new ConcurrentHashMap();
/**
* 获取指定的value，如果key不存在或者已过期，则返回null
*
* @param key
* @return
*/
public static Object get(String key) {
if (!cacheMap.containsKey(key)) {
return null;
}
if (expireTimeMap.containsKey(key)) {
if (expireTimeMap.get(key) System.currentTimeMillis()) {// 缓存失效，已过期
return null;
}
}
return cacheMap.get(key);
}
/**
* @param key
* @param
* @return
*/
public static T getT(String key) {
Object obj =get(key);
return obj ==null ?null : (T) obj;
}
/**
* 设置value（不过期）
*
* @param key
* @param value
*/
public static void set(String key, Object value) {
cacheMap.put(key, value);
}
/**
* 设置value
*
* @param key
* @param value
* @param second 过期时间（秒）
*/
public static void set(final String key, Object value,int second) {
final long expireTime = System.currentTimeMillis() + second *1000;
cacheMap.put(key, value);
expireTimeMap.put(key, expireTime);
if (cacheMap.size() 2) {// 清除过期数据
new Thread(new Runnable() {
@Override
public void run() {
// 此处若使用foreach进行循环遍历，删除过期数据，会抛出java.util.ConcurrentModificationException异常
Iterator iterator =cacheMap.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry entry = iterator.next();
if (expireTimeMap.containsKey(entry.getKey())) {
long expireTime =expireTimeMap.get(key);
if (System.currentTimeMillis() expireTime) {
iterator.remove();
expireTimeMap.remove(entry.getKey());
}
}
}
}
}).start();
}
}
/**
* key是否存在
*
* @param key
* @return
*/
public static boolean isExist(String key) {
return cacheMap.containsKey(key);
}
/**
* 清除缓存
*
* @param key
*/
public static void remove(String key) {
cacheMap.remove(key);
}
public static void main(String[] args) {
CacheWithExpireUtil.set("testKey_1","testValue_1");
CacheWithExpireUtil.set("testKey_2","testValue_2",10);
CacheWithExpireUtil.set("testKey_3","testValue_3");
CacheWithExpireUtil.set("testKey_4","testValue_4",1);
Object testKey_2 = CacheWithExpireUtil.get("testKey_2");
System.out.println(testKey_2);
}
}
java怎样将数据保存到缓存中，之后再保存
Java中可以使用队列来保存数据，当使用的时候，加上锁，防止其他进程访问，当不用的时候保存到数据库里面，示例如下：
package com.henry;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class CacheDataTest {
static MapInteger,Object dataMap=new HashMapInteger,Object();
static ReadWriteLock lock=new ReentrantReadWriteLock();//创建读写锁的实例
static Object getData(Integer key){
lock.readLock().lock();//读取前先上锁
Object val=null;
try{
val=dataMap.get(key);
if(val == null){
// Must release read lock before acquiring write lock
lock.readLock().unlock();
lock.writeLock().lock();
try{
//可能已经由其他线程写入数据
if(val==null){
//dataMap.put(key, "");//query from db
val=queryDataFromDB(key);
}
}finally{
//Downgrade by acquiring read lock before releasing write lock
lock.readLock().lock();
// Unlock write, still hold read
lock.writeLock().unlock();
}
}
}finally{
lock.readLock().unlock();//最后一定不要忘记释放锁
}
System.out.println("get data key="+key+"val="+val);
return val;
}
static Object queryDataFromDB(Integer key){
Object val=new Random().nextInt(1000);
dataMap.put(key, val);
System.out.println("write into data key="+key+"val="+val);
return val;
}
public static void main(String[] args) {
for(int i=0;i10;i++){
new Thread(new Runnable(){public void run() {
getData(new Random().nextInt(5));
}}).start();
}
}
}
java map可以放多少数据
map由key value键值对组成，具体放多少数据和你的服务器运行时的内存有关系，同时也和你代码中及时清理无效缓存有关系。
一般编写代码中不会去考虑放多少数据问题，除非你数据量超级大对内存要求比较高。这个时候需要对代码和服务器进行优化
java怎么实现map 缓存技术
/**
* 缓存池
* @author xiaoquan
* @create 2015年3月13日 上午10:32:13
* @see
*/
public class CachePool {
private static CachePool instance;//缓存池唯一实例
private static MapString,Object cacheItems;//缓存Map
private CachePool(){
cacheItems = new HashMapString,Object();
}
/**
* 得到唯一实例
* @return
*/
public synchronized static CachePool getInstance(){
if(instance == null){
instance = new CachePool();
}
return instance;
}
/**
* 清除所有Item缓存
*/
public synchronized void clearAllItems(){
cacheItems.clear();
}
/**
* 获取缓存实体
* @param name
* @return
*/
public synchronized Object getCacheItem(String name){
if(!cacheItems.containsKey(name)){
return null;
}
CacheItem cacheItem = (CacheItem) cacheItems.get(name);
if(cacheItem.isExpired()){
return null;
}
return cacheItem.getEntity();
}
/**
* 存放缓存信息
* @param name
* @param obj
* @param expires
*/
public synchronized void putCacheItem(String name,Object obj,long expires){
if(!cacheItems.containsKey(name)){
cacheItems.put(name, new CacheItem(obj, expires));
}
CacheItem cacheItem = (CacheItem) cacheItems.get(name);
cacheItem.setCreateTime(new Date());
cacheItem.setEntity(obj);
cacheItem.setExpireTime(expires);
}
public synchronized void putCacheItem(String name,Object obj){
putCacheItem(name,obj,-1);
}
/**
* 移除缓存数据
* @param name
*/
public synchronized void removeCacheItem(String name){
if(!cacheItems.containsKey(name)){
return;
}
cacheItems.remove(name);
}
/**
* 获取缓存数据的数量
* @return
*/
public int getSize(){
return cacheItems.size();
}
}
public class CacheItem {
private Date createTime = new Date();//创建缓存的时间
private long expireTime = 1;//缓存期满的时间
private Object entity;//缓存的实体
public CacheItem(Object obj,long expires){
this.entity = obj;
this.expireTime = expires;
}
public boolean isExpired(){
return (expireTime != -1 new Date().getTime()-createTime.getTime() expireTime);
}
/**
* 省略getter、setter方法
*/
}
关于javamap缓存和map实现缓存的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。