Java 缓存高并发 java内存缓存

转载

mob64ca13ffd0f1 2023-10-12 12:42:51

文章标签 Java 缓存高并发缓存 java System 文章分类 Java 后端开发

一：我们要对计算机的缓存定义有一定的了解：缓存是CPU的一部分，它存在于CPU中，但是事实上CPU上不可能存在海量数据，所以java的缓存根本意义上不叫缓存。

二：一种是静态RAM，SRAM；一种是动态RAM，DRAM。前者的存储速度要比后者快得多，我们现在使用的内存一般都是动态RAM。

缓存通常都是静态RAM，速度是非常的快，

但是静态RAM集成度低（存储相同的数据，静态RAM的体积是动态RAM的6倍），

价格高（同容量的静态RAM是动态RAM的四倍），

由此可见，扩大静态RAM作为缓存是一个非常愚蠢的行为，

但是为了提高系统的性能和速度，我们必须要扩大缓存，

这样就有了一个折中的方法，不扩大原来的静态RAM缓存，而是增加一些高速动态RAM做为缓存，

这些高速动态RAM速度要比常规动态RAM快，但比原来的静态RAM缓存慢，

我们把原来的静态ram缓存叫一级缓存，而把后来增加的动态RAM叫二级缓存。

一级缓存和二级缓存中的内容都是内存中访问频率高的数据的复制品（映射），它们的存在都是为了减少高速CPU对慢速内存的访问。

通常CPU找数据或指令的顺序是：先到一级缓存中找，找不到再到二级缓存中找，如果还找不到就只有到内存中找了

JAVA缓存有两种:
一、文件缓存,是指把数据存储在磁盘上，可以XML格式，也可以序列化文件DAT格式还是其它文件格式。
二、内存缓存，也就是实现一个类中静态Map,对这个Map进行常规的增删查。

其代码如下：

目录 [隐藏]

1 Cache类
2 CacheManager类

JAVA缓存-Cache类

public class Cache { 
 private String key;//缓存ID 
 private Object value;//缓存数据 
 private long timeOut;//更新时间 
 private boolean expired; //是否终止 
 public Cache() { 
 super(); 
 } 
 public Cache(String key, Object value, long timeOut, boolean expired) { 
 this.key = key; 
 this.value = value; 
 this.timeOut = timeOut; 
 this.expired = expired; 
 } 
 public String getKey() { 
 return key; 
 } 
 public long getTimeOut() { 
 return timeOut; 
 } 
 public Object getValue() { 
 return value; 
 } 
 public void setKey(String string) { 
 key = string; 
 } 
 public void setTimeOut(long l) { 
 timeOut = l; 
 } 
 public void setValue(Object object) { 
 value = object; 
 } 
 public boolean isExpired() { 
 return expired; 
 } 
 public void setExpired(boolean b) { 
 expired = b; 
 } 
 } 
 //测试类， 
 class Test { 
 public static void main(String[] args) { 
 System.out.println(CacheManager.getSimpleFlag("alksd")); 
 // CacheManager.putCache("abc", new Cache()); 
 // CacheManager.putCache("def", new Cache()); 
 // CacheManager.putCache("ccc", new Cache()); 
 // CacheManager.clearOnly(""); 
 // Cache c = new Cache(); 
 // for (int i = 0; i < 10; i++) { 
 // CacheManager.putCache("" + i, c); 
 // } 
 // CacheManager.putCache("aaaaaaaa", c); 
 // CacheManager.putCache("abchcy;alskd", c); 
 // CacheManager.putCache("cccccccc", c); 
 // CacheManager.putCache("abcoqiwhcy", c); 
 // System.out.println("删除前的大小："+CacheManager.getCacheSize()); 
 // CacheManager.getCacheAllkey(); 
 // CacheManager.clearAll("aaaa"); 
 // System.out.println("删除后的大小："+CacheManager.getCacheSize()); 
 // CacheManager.getCacheAllkey(); 
 } 
 }

JAVA缓存-CacheManager类

public class CacheManager { 
 private static HashMap cacheMap = new HashMap(); 
 //单实例构造方法 
 private CacheManager() { 
 super(); 
 } 
 //获取布尔值的缓存 
 public static boolean getSimpleFlag(String key){ 
 try{ 
 return (Boolean) cacheMap.get(key); 
 }catch(NullPointerException e){ 
 return false; 
 } 
 } 
 public static long getServerStartdt(String key){ 
 try { 
 return (Long)cacheMap.get(key); 
 } catch (Exception ex) { 
 return 0; 
 } 
 } 
 //设置布尔值的缓存 
 public synchronized static boolean setSimpleFlag(String key,boolean flag){ 
 if (flag && getSimpleFlag(key)) {//假如为真不允许被覆盖 
 return false; 
 }else{ 
 cacheMap.put(key, flag); 
 return true; 
 } 
 } 
 public synchronized static boolean setSimpleFlag(String key,long serverbegrundt){ 
 if (cacheMap.get(key) == null) { 
 cacheMap.put(key,serverbegrundt); 
 return true; 
 }else{ 
 return false; 
 } 
 } 
 //得到缓存。同步静态方法 
 private synchronized static Cache getCache(String key) { 
 return (Cache) cacheMap.get(key); 
 } 
 //判断是否存在一个缓存 
 private synchronized static boolean hasCache(String key) { 
 return cacheMap.containsKey(key); 
 }
 //清除所有缓存 
 public synchronized static void clearAll() { 
 cacheMap.clear(); 
 } 
 //清除某一类特定缓存,通过遍历HASHMAP下的所有对象，来判断它的KEY与传入的TYPE是否匹配 
 public synchronized static void clearAll(String type) { 
 Iterator i = cacheMap.entrySet().iterator(); 
 String key; 
 ArrayList arr = new ArrayList(); 
 try { 
 while (i.hasNext()) { 
 java.util.Map.Entry entry = (java.util.Map.Entry) i.next(); 
 key = (String) entry.getKey(); 
 if (key.startsWith(type)) { //如果匹配则删除掉 
 arr.add(key); 
 } 
 } 
 for (int k = 0; k < arr.size(); k++) { 
 clearOnly(arr.get(k)); 
 } 
 } catch (Exception ex) { 
 ex.printStackTrace(); 
 } 
 } 
 //清除指定的缓存 
 public synchronized static void clearOnly(String key) { 
 cacheMap.remove(key); 
 } 
 //载入缓存 
 public synchronized static void putCache(String key, Cache obj) { 
 cacheMap.put(key, obj); 
 } 
 //获取缓存信息 
 public static Cache getCacheInfo(String key) { 
 if (hasCache(key)) { 
 Cache cache = getCache(key); 
 if (cacheExpired(cache)) { //调用判断是否终止方法 
 cache.setExpired(true); 
 } 
 return cache; 
 }else 
 return null; 
 } 
 //载入缓存信息 
 public static void putCacheInfo(String key, Cache obj, long dt,boolean expired) { 
 Cache cache = new Cache(); 
 cache.setKey(key); 
 cache.setTimeOut(dt + System.currentTimeMillis()); //设置多久后更新缓存 
 cache.setValue(obj); 
 cache.setExpired(expired); //缓存默认载入时，终止状态为FALSE 
 cacheMap.put(key, cache); 
 } 
 //重写载入缓存信息方法 
 public static void putCacheInfo(String key,Cache obj,long dt){ 
 Cache cache = new Cache(); 
 cache.setKey(key); 
 cache.setTimeOut(dt+System.currentTimeMillis()); 
 cache.setValue(obj); 
 cache.setExpired(false); 
 cacheMap.put(key,cache); 
 } 
 //判断缓存是否终止 
 public static boolean cacheExpired(Cache cache) { 
 if (null == cache) { //传入的缓存不存在 
 return false; 
 } 
 long nowDt = System.currentTimeMillis(); //系统当前的毫秒数 
 long cacheDt = cache.getTimeOut(); //缓存内的过期毫秒数 
 if (cacheDt <= 0||cacheDt>nowDt) { //过期时间小于等于零时,或者过期时间大于当前时间时，则为FALSE 
 return false; 
 } else { //大于过期时间 即过期 
 return true; 
 } 
 } 
 //获取缓存中的大小 
 public static int getCacheSize() { 
 return cacheMap.size(); 
 } 
 //获取指定的类型的大小 
 public static int getCacheSize(String type) { 
 int k = 0; 
 Iterator i = cacheMap.entrySet().iterator(); 
 String key; 
 try { 
 while (i.hasNext()) { 
 java.util.Map.Entry entry = (java.util.Map.Entry) i.next(); 
 key = (String) entry.getKey(); 
 if (key.indexOf(type) != -1) { //如果匹配则删除掉 
 k++; 
 } 
 } 
 } catch (Exception ex) { 
 ex.printStackTrace(); 
 } 
 return k; 
 } 
 //获取缓存对象中的所有键值名称 
 public static ArrayList getCacheAllkey() { 
 ArrayList a = new ArrayList(); 
 try { 
 Iterator i = cacheMap.entrySet().iterator(); 
 while (i.hasNext()) { 
 java.util.Map.Entry entry = (java.util.Map.Entry) i.next(); 
 a.add((String) entry.getKey()); 
 } 
 } catch (Exception ex) {} finally { 
 return a; 
 } 
 } 
 //获取缓存对象中指定类型 的键值名称 
 public static ArrayList getCacheListkey(String type) { 
 ArrayList a = new ArrayList(); 
 String key; 
 try { 
 Iterator i = cacheMap.entrySet().iterator(); 
 while (i.hasNext()) { 
 java.util.Map.Entry entry = (java.util.Map.Entry) i.next(); 
 key = (String) entry.getKey(); 
 if (key.indexOf(type) != -1) { 
 a.add(key); 
 } 
 } 
 } catch (Exception ex) {} finally { 
 return a; 
 } 
 } 
 }

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。