java缓存技术的介绍

最新推荐文章于 2024-06-23 23:26:51 发布
最新推荐文章于 2024-06-23 23:26:51 发布
阅读量1.3k 收藏 7
点赞数 2
分类专栏： 缓存 文章标签： 缓存

java缓存技术的介绍

一、什么是缓存
1、Cache是高速缓冲存储器 一种特殊的存储器子系统，其中复制了频繁使用的数据以利于快速访问
2、凡是位于速度相差较大的两种硬件/软件之间的，用于协调两者数据传输速度差异的结构，均可称之为 Cache

二、缓存的分类
1、基于web应用的系统架构图

2、在系统架构的不同层级之间，为了加快访问速度，都可以存在缓存

  • 操作系统磁盘缓存->减少磁盘机械操作
  • 数据库缓存->减少文件系统I/O
  • 应用程序缓存->减少对数据库的查询 
  • Web服务器缓存->减少应用服务器请求
  • 客户端浏览器缓存->减少对网站的访问

三、操作系统缓存
1、文件系统提供的Disk Cache：操作系统会把经常访问到的文件内容放入到内存当中，由文件系统来管理
2、当应用程序通过文件系统访问磁盘文件的时候，操作系统从Disk Cache当中读取文件内容，加速了文件读取速度
3、Disk Cache由操作系统来自动管理，一般不用人工干预，但应当保证物理内存充足，以便于操作系统可以使用尽量多的内存充当Disk Cache，加速文件读取速度
4、特殊的应用程序对文件系统Disk Cache有很高的要求，会绕开文件系统Disk Cache，直接访问磁盘分区，自己实现Disk 
5、Cache策略

  • Oracle的raw device(裸设备) – 直接抛弃文件系统
  • MySQL的InnoDB： innodb_flush_method = O_DIRECT


四、数据库缓存
1、重要性

  • 数据库通常是企业应用系统最核心的部分
  • 数据库保存的数据量通常非常庞大
  • 数据库查询操作通常很频繁，有时还很复杂
  • 以上原因造成数据库查询会引起非常频繁的磁盘I/O读取操作，迫使CPU挂起等待，数据库性能极度低下

2、缓存策略
     a、Query Cache

    • 以SQL作为key值缓存查询结果集
    • 一旦查询涉及的表记录被修改，缓存就会被自动删除
    • 设置合适的Query Cache会极大提高数据库性能
    • Query Cache并非越大越好，过大的Qquery Cache会浪费内存。
    • MySQL: query_cache_size= 128M

     b、Data Buffer

    • data buffer是数据库数据在内存中的容器
    • data buffer的命中率直接决定了数据库的性能
    • data buffer越大越好，多多益善
    • MySQL的InnoDB buffer：innodb_buffer_pool_size = 2G
    • MySQL建议buffer pool开大到服务器物理内存60-80%

五、应用程序缓存
1、对象缓存

  • 由O/R Mapping框架例如Hibernate提供，透明性访问，细颗粒度缓存数据库查询结果，无需业务代码显式编程，是最省事的缓存策略
  • 当软件结构按照O/R Mapping框架的要求进行针对性设计，使用对象缓存将会极大降低Web系统对于数据库的访问请求
  • 良好的设计数据库结构和利用对象缓存，能够提供极高的性能，对象缓存适合OLTP（联机事务处理）应用

2、查询缓存

  • 对数据库查询结果集进行缓存，类似数据库的Query Cache
  • 适用于一些耗时，但是时效性要求比较低的场景。查询缓存和对象缓存适用的场景不一样，是互为补充的
  • 当查询结果集涉及的表记录被修改以后，需要注意清理缓存

3、页面缓存
     a、作用

    • 针对页面的缓存技术不但可以减轻数据库服务器压力，还可以减轻应用服务器压力
    • 好的页面缓存可以极大提高页面渲染速度
    • 页面缓存的难点在于如何清理过期的缓存

    b、分类
         I、动态页面静态化

    • 利用模板技术将访问过一次的动态页面生成静态html，同时修改页面链接，下一次请求直接访问静态链接页面
    • 动态页面静态化技术的广泛应用于互联网CMS/新闻类Web应用，但也有BBS应用使用该技术，例如Discuz!
    • 无法进行权限验证，无法显示个性化信息
    • 可以使用AJAX请求弥补动态页面静态化的某些缺点

        II、Servlet缓存

    • 针对URL访问返回的页面结果进行缓存，适用于粗粒度的页面缓存，例如新闻发布
    • 可以进行权限的检查
    • OScache提供了简单的Servlet缓存(通过web.xml中的配置)
    • 也可以自己编程实现Servlet缓存

        III、页面内部缓存

    • 针对动态页面的局部片断内容进行缓存，适用于一些个性化但不经常更新的页面(例如博客)
    • OSCache提供了简单的页面缓存
    • 可以自行扩展JSP Tag实现页面局部缓存


六、web服务器端缓存

  • 基于代理服务器模式的Web服务器端缓存，如squid/nginx
  • Web服务器缓存技术被用来实现CDN（内容分发网络 content delivery network）
  • 被国内主流门户网站大量采用
  • 不需要编程，但仅限于新闻发布类网站，页面实时性要求不高

七、基于ajax的浏览器缓存

  • 使用AJAX调用的时候，将数据库在浏览器端缓存
  • 只要不离开当前页面，不刷新当前页面，就可以直接读取缓存数据
  • 只适用于使用AJAX技术的页面

5个强大的Java分布式缓存框架推荐

在开发中大型Java软件项目时，很多Java架构师都会遇到数据库读写瓶颈，如果你在系统架构时并没有将缓存策略考虑进去，或者并没有选择更优的缓存策略，那么到时候重构起来将会是一个噩梦。本文主要是分享了5个常用的Java分布式缓存框架，这些缓存框架支持多台服务器的缓存读写功能，可以让你的缓存系统更容易扩展。

1、Ehcache – Java分布式缓存框架

Ehcache是一个Java实现的开源分布式缓存框架，EhCache 可以有效地减轻数据库的负载，可以让数据保存在不同服务器的内存中，在需要数据的时候可以快速存取。同时EhCache 扩展非常简单，官方提供的Cache配置方式有好几种。你可以通过声明配置、在xml中配置、在程序里配置或者调用构造方法时传入不同的参数。

官方网站：http://ehcache.org/

使用教程：http://www.codeceo.com/article/java-ehcache.html

2、Cacheonix – 高性能Java分布式缓存系统

Cacheonix同样也是一个基于Java的分布式集群缓存系统，它同样可以帮助你实现分布式缓存的部署。

官方网站：http://www.cacheonix.com/

使用教程：http://www.codeceo.com/article/java-cacheonix.html

3、ASimpleCache – 轻量级Android缓存框架

ASimpleCache是一款基于Android的轻量级缓存框架，它只有一个Java文件，ASimpleCache基本可以缓存常用的Android对象，包括普通字符串、JSON对象、经过序列化的Java对象、字节数组等。

官方网站：https://github.com/yangfuhai/ASimpleCache

使用教程：http://www.codeceo.com/article/asimplecache-android-cache.html

4、JBoss Cache – 基于事物的Java缓存框架

JBoss Cache是一款基于Java的事务处理缓存系统，它的目标是构建一个以Java框架为基础的集群解决方案，可以是服务器应用，也可以是Java SE应用。

官方网站：http://jbosscache.jboss.org/

使用教程：http://www.codeceo.com/article/jboss-cache-java.html

5、Voldemort – 基于键-值（key-value）的缓存框架

Voldemort是一款基于Java开发的分布式键-值缓存系统，像JBoss Cache一样，Voldemort同样支持多台服务器之间的缓存同步，以增强系统的可靠性和读取性能。

官方网站：http://www.project-voldemort.com/voldemort/

使用教程：http://www.codeceo.com/article/voldemort-java-key-value-catch.html
OSCache
　　OSCache是个一个广泛采用的高性能的J2EE缓存框架，OSCache能用于任何Java应用程序的普通的缓存解决方案。OSCache有以下特点：
　　缓存任何对象，你可以不受限制的缓存部分jsp页面或HTTP请求，任何java对象都可以缓存。
　　拥有全面的API--OSCache API给你全面的程序来控制所有的OSCache特性。
　　永久缓存--缓存能随意的写入硬盘，因此允许昂贵的创建（expensive-to-create）数据来保持缓存，甚至能让应用重启。
　　支持集群--集群缓存数据能被单个的进行参数配置，不需要修改代码。
　　缓存记录的过期--你可以有最大限度的控制缓存对象的过期，包括可插入式的刷新策略（如果默认性能不需要时）。
　　官方网站 http://www.opensymphony.com/oscache/
　　
　　Java Caching System
　　JSC(Java Caching System)是一个用分布式的缓存系统，是基于服务器的java应用程序。它是通过提供管理各种动态缓存数据来加速动态web应用。
　　JCS和其他缓存系统一样，也是一个用于高速读取，低速写入的应用程序。
　　动态内容和报表系统能够获得更好的性能。
　　如果一个网站，有重复的网站结构，使用间歇性更新方式的数据库（而不是连续不断的更新数据库），被重复搜索出相同结果的，就能够通过执行缓存方式改进其性能和伸缩性。
　　官方网站 http://jakarta.apache.org/turbine/jcs/
　　
　　EHCache
　　EHCache 是一个纯java的在进程中的缓存，它具有以下特性：快速，简单，为Hibernate2.1充当可插入的缓存，最小的依赖性，全面的文档和测试。
　　官方网站 http://ehcache.sourceforge.net/
　　
　　JCache
　　JCache是个开源程序，正在努力成为JSR-107开源规范，JSR-107规范已经很多年没改变了。这个版本仍然是构建在最初的功能定义上。
　　官方网站 http://jcache.sourceforge.net/

　　ShiftOne
　　ShiftOne Java Object Cache是一个执行一系列严格的对象缓存策略的Java lib，就像一个轻量级的配置缓存工作状态的框架。
　　官方网站 http://jocache.sourceforge.net/

　　SwarmCache
　　SwarmCache是一个简单且有效的分布式缓存，它使用IP multicast与同一个局域网的其他主机进行通讯，是特别为集群和数据驱动web应用程序而设计的。SwarmCache能够让典型的读操作大大超过写操作的这类应用提供更好的性能支持。
　　SwarmCache使用JavaGroups来管理从属关系和分布式缓存的通讯。
　　官方网站 http://swarmcache.sourceforge.net

　　TreeCache / JBossCache
　 　JBossCache是一个复制的事务处理缓存，它允许你缓存企业级应用数据来更好的改善性能。缓存数据被自动复制，让你轻松进行JBoss服务器之间 的集群工作。JBossCache能够通过JBoss应用服务或其他J2EE容器来运行一个MBean服务，当然，它也能独立运行。
　　JBossCache包括两个模块：TreeCache和TreeCacheAOP。
　　TreeCache --是一个树形结构复制的事务处理缓存。
　　TreeCacheAOP --是一个“面向对象”缓存，它使用AOP来动态管理POJO
　　官方网站 http://www.jboss.org/products/jbosscache

　　WhirlyCache
　　Whirlycache是一个快速的、可配置的、存在于内存中的对象的缓存。它能够通过缓存对象来加快网站或应用程序的速度，否则就必须通过查询数据库或其他代价较高的处理程序来建立。

Java 中常用缓存Cache机制的实现

所谓缓存，就是将程序或系统经常要调用的对象存在内存中，以便其使用时可以快速调用，不必再去创建新的重复的实例。这样做可以减少系统开销，提高系统效率。

缓存主要可分为二大类:

一、通过文件缓存：顾名思义，文件缓存是指把数据存储在磁盘上，不管你是以XML格式，序列化文件DAT格式还是其它文件格式； 

二、内存缓存：也就是实现一个类中静态Map，对这个Map进行常规的增删查.

代码如下 ：

  
  
  1. package lhm.hcy.guge.frameset.cache; 
  2.  
  3. import java.util.*; 
  4.  
  5.  //Description: 管理缓存 
  6.  
  7.  //可扩展的功能：当chche到内存溢出时必须清除掉最早期的一些缓存对象，这就要求对每个缓存对象保存创建时间 
  8.  
  9. public class CacheManager { 
  10.     private static HashMap cacheMap = new HashMap(); 
  11.  
  12.     //单实例构造方法 
  13.     private CacheManager() { 
  14.         super(); 
  15.     } 
  16.     //获取布尔值的缓存 
  17.     public static boolean getSimpleFlag(String key){ 
  18.         try{ 
  19.             return (Boolean) cacheMap.get(key); 
  20.         }catch(NullPointerException e){ 
  21.             return false; 
  22.         } 
  23.     } 
  24.     public static long getServerStartdt(String key){ 
  25.         try { 
  26.             return (Long)cacheMap.get(key); 
  27.         } catch (Exception ex) { 
  28.             return 0; 
  29.         } 
  30.     } 
  31.     //设置布尔值的缓存 
  32.     public synchronized static boolean setSimpleFlag(String key,boolean flag){ 
  33.         if (flag && getSimpleFlag(key)) {//假如为真不允许被覆盖 
  34.             return false; 
  35.         }else{ 
  36.             cacheMap.put(key, flag); 
  37.             return true; 
  38.         } 
  39.     } 
  40.     public synchronized static boolean setSimpleFlag(String key,long serverbegrundt){ 
  41.         if (cacheMap.get(key) == null) { 
  42.             cacheMap.put(key,serverbegrundt); 
  43.             return true; 
  44.         }else{ 
  45.             return false; 
  46.         } 
  47.     } 
  48.  
  49.  
  50.     //得到缓存。同步静态方法 
  51.     private synchronized static Cache getCache(String key) { 
  52.         return (Cache) cacheMap.get(key); 
  53.     } 
  54.  
  55.     //判断是否存在一个缓存 
  56.     private synchronized static boolean hasCache(String key) { 
  57.         return cacheMap.containsKey(key); 
  58.     } 
  59.  
  60.     //清除所有缓存 
  61.     public synchronized static void clearAll() { 
  62.         cacheMap.clear(); 
  63.     } 
  64.  
  65.     //清除某一类特定缓存,通过遍历HASHMAP下的所有对象，来判断它的KEY与传入的TYPE是否匹配 
  66.     public synchronized static void clearAll(String type) { 
  67.         Iterator i = cacheMap.entrySet().iterator(); 
  68.         String key; 
  69.         ArrayList arr = new ArrayList(); 
  70.         try { 
  71.             while (i.hasNext()) { 
  72.                 java.util.Map.Entry entry = (java.util.Map.Entry) i.next(); 
  73.                 key = (String) entry.getKey(); 
  74.                 if (key.startsWith(type)) { //如果匹配则删除掉 
  75.                     arr.add(key); 
  76.                 } 
  77.             } 
  78.             for (int k = 0; k < arr.size(); k++) { 
  79.                 clearOnly(arr.get(k)); 
  80.             } 
  81.         } catch (Exception ex) { 
  82.             ex.printStackTrace(); 
  83.         } 
  84.     } 
  85.  
  86.     //清除指定的缓存 
  87.     public synchronized static void clearOnly(String key) { 
  88.         cacheMap.remove(key); 
  89.     } 
  90.  
  91.     //载入缓存 
  92.     public synchronized static void putCache(String key, Cache obj) { 
  93.         cacheMap.put(key, obj); 
  94.     } 
  95.  
  96.     //获取缓存信息 
  97.     public static Cache getCacheInfo(String key) { 
  98.  
  99.         if (hasCache(key)) { 
  100.             Cache cache = getCache(key); 
  101.             if (cacheExpired(cache)) { //调用判断是否终止方法 
  102.                 cache.setExpired(true); 
  103.             } 
  104.             return cache; 
  105.         }else 
  106.             return null; 
  107.     } 
  108.  
  109.     //载入缓存信息 
  110.     public static void putCacheInfo(String key, Cache obj, long dt,boolean expired) { 
  111.         Cache cache = new Cache(); 
  112.         cache.setKey(key); 
  113.         cache.setTimeOut(dt + System.currentTimeMillis()); //设置多久后更新缓存 
  114.         cache.setValue(obj); 
  115.         cache.setExpired(expired); //缓存默认载入时，终止状态为FALSE 
  116.         cacheMap.put(key, cache); 
  117.     } 
  118.     //重写载入缓存信息方法 
  119.     public static void putCacheInfo(String key,Cache obj,long dt){ 
  120.         Cache cache = new Cache(); 
  121.         cache.setKey(key); 
  122.         cache.setTimeOut(dt+System.currentTimeMillis()); 
  123.         cache.setValue(obj); 
  124.         cache.setExpired(false); 
  125.         cacheMap.put(key,cache); 
  126.     } 
  127.  
  128.     //判断缓存是否终止 
  129.     public static boolean cacheExpired(Cache cache) { 
  130.         if (null == cache) { //传入的缓存不存在 
  131.             return false; 
  132.         } 
  133.         long nowDt = System.currentTimeMillis(); //系统当前的毫秒数 
  134.         long cacheDt = cache.getTimeOut(); //缓存内的过期毫秒数 
  135.         if (cacheDt <= 0||cacheDt>nowDt) { //过期时间小于等于零时,或者过期时间大于当前时间时，则为FALSE 
  136.             return false; 
  137.         } else { //大于过期时间 即过期 
  138.             return true; 
  139.         } 
  140.     } 
  141.  
  142.     //获取缓存中的大小 
  143.     public static int getCacheSize() { 
  144.         return cacheMap.size(); 
  145.     } 
  146.  
  147.     //获取指定的类型的大小 
  148.     public static int getCacheSize(String type) { 
  149.         int k = 0; 
  150.         Iterator i = cacheMap.entrySet().iterator(); 
  151.         String key; 
  152.         try { 
  153.             while (i.hasNext()) { 
  154.                 java.util.Map.Entry entry = (java.util.Map.Entry) i.next(); 
  155.                 key = (String) entry.getKey(); 
  156.                 if (key.indexOf(type) != -1) { //如果匹配则删除掉 
  157.                     k++; 
  158.                 } 
  159.             } 
  160.         } catch (Exception ex) { 
  161.             ex.printStackTrace(); 
  162.         } 
  163.  
  164.         return k; 
  165.     } 
  166.  
  167.     //获取缓存对象中的所有键值名称 
  168.     public static ArrayList getCacheAllkey() { 
  169.         ArrayList a = new ArrayList(); 
  170.         try { 
  171.             Iterator i = cacheMap.entrySet().iterator(); 
  172.             while (i.hasNext()) { 
  173.                 java.util.Map.Entry entry = (java.util.Map.Entry) i.next(); 
  174.                 a.add((String) entry.getKey()); 
  175.             } 
  176.         } catch (Exception ex) {} finally { 
  177.             return a; 
  178.         } 
  179.     } 
  180.  
  181.     //获取缓存对象中指定类型 的键值名称 
  182.     public static ArrayList getCacheListkey(String type) { 
  183.         ArrayList a = new ArrayList(); 
  184.         String key; 
  185.         try { 
  186.             Iterator i = cacheMap.entrySet().iterator(); 
  187.             while (i.hasNext()) { 
  188.                 java.util.Map.Entry entry = (java.util.Map.Entry) i.next(); 
  189.                 key = (String) entry.getKey(); 
  190.                 if (key.indexOf(type) != -1) { 
  191.                     a.add(key); 
  192.                 } 
  193.             } 
  194.         } catch (Exception ex) {} finally { 
  195.             return a; 
  196.         } 
  197.     } 
  198.  
  199. } 
  200.  
  201.  
  202. package lhm.hcy.guge.frameset.cache; 
  203.  
  204. public class Cache { 
  205.         private String key;//缓存ID 
  206.         private Object value;//缓存数据 
  207.         private long timeOut;//更新时间 
  208.         private boolean expired; //是否终止 
  209.         public Cache() { 
  210.                 super(); 
  211.         } 
  212.  
  213.         public Cache(String key, Object value, long timeOut, boolean expired) { 
  214.                 this.key = key; 
  215.                 this.value = value; 
  216.                 this.timeOut = timeOut; 
  217.                 this.expired = expired; 
  218.         } 
  219.  
  220.         public String getKey() { 
  221.                 return key; 
  222.         } 
  223.  
  224.         public long getTimeOut() { 
  225.                 return timeOut; 
  226.         } 
  227.  
  228.         public Object getValue() { 
  229.                 return value; 
  230.         } 
  231.  
  232.         public void setKey(String string) { 
  233.                 key = string; 
  234.         } 
  235.  
  236.         public void setTimeOut(long l) { 
  237.                 timeOut = l; 
  238.         } 
  239.  
  240.         public void setValue(Object object) { 
  241.                 value = object; 
  242.         } 
  243.  
  244.         public boolean isExpired() { 
  245.                 return expired; 
  246.         } 
  247.  
  248.         public void setExpired(boolean b) { 
  249.                 expired = b; 
  250.         } 
  251. } 
  252.  
  253. //测试类， 
  254. class Test { 
  255.     public static void main(String[] args) { 
  256.         System.out.println(CacheManager.getSimpleFlag("alksd")); 
  257. //        CacheManager.putCache("abc", new Cache()); 
  258. //        CacheManager.putCache("def", new Cache()); 
  259. //        CacheManager.putCache("ccc", new Cache()); 
  260. //        CacheManager.clearOnly(""); 
  261. //        Cache c = new Cache(); 
  262. //        for (int i = 0; i < 10; i++) { 
  263. //            CacheManager.putCache("" + i, c); 
  264. //        } 
  265. //        CacheManager.putCache("aaaaaaaa", c); 
  266. //        CacheManager.putCache("abchcy;alskd", c); 
  267. //        CacheManager.putCache("cccccccc", c); 
  268. //        CacheManager.putCache("abcoqiwhcy", c); 
  269. //        System.out.println("删除前的大小："+CacheManager.getCacheSize()); 
  270. //        CacheManager.getCacheAllkey(); 
  271. //        CacheManager.clearAll("aaaa"); 
  272. //        System.out.println("删除后的大小："+CacheManager.getCacheSize()); 
  273. //        CacheManager.getCacheAllkey(); 
  274.  
  275.  
  276.     } 
  277. } 

volts
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 文件 缓存_JAVA缓存技术
weixin_35510761的博客
02-12 1616
转载地址：http://blog.csdn.net/madun/article/details/8569860最近再ITEYE上看到关于讨论JAVA缓存技术的帖子比较多，自己不懂，所以上网大概搜了下，找到一篇，暂作保存，后面如果有用到可以参考。此为转贴，帖子来处:http://cogipard.info/articles/cache-static-files-with-jnotify-and-eh...
java中redis缓存技术的使用
qq_35750547的博客
02-23 5795
关于Redis的简单介绍 REmote DIctionary Server（redis）缓存技术是一个高性能的key-value存储系统。 它通常被称为数据结构服务器，因为值（value）可以是字符串（String），哈希（Hash），列表（List），集合（Sets）和有序集合（sorted sets）等类型。 Redis与其他key-value缓存产品相比有以下优点： 1.Redis支...
缓存详解-在java项目中使用缓存
qq_32384985的博客
08-05 4226
一、概述 在java项目中经常有使用缓存的场景，这时候如何使用缓存就很重要了，本篇文章言简意赅，带你读透缓存 二、java常用的缓存 在java项目中经常使用到的缓存主要分为两个种类 1、内存类 java中的Map、List等容器实现类可以用来作为本地缓存。 一些本地缓存框架，类似ehcache，guava中实现的缓存。 2、中间件类 redis、memcache等等 三、使用缓存将会面临的一些问...
java 缓存教程_Java实现本地缓存
weixin_28721019的博客
02-13 403
对于缓存的作用不言而喻，可以提高查询效率，比去DB查询的速度要快。项目中我们经常会使用Nosql数据库，如Redis等做缓存。但是对于数据量很小的，访问非常频繁的，我们也可以存在本地缓存中。我将利用concurrentHashMap等集合容器实现一个本地缓存。1.基于concurrentHashMap的本地缓存。本地缓存一般使用键值对方式的存储，那么在Java中肯定是选用map,由于concurr...
如何在Java中实现缓存机制？
最新发布
微赚淘客系统开发者博客
06-23 496
大家好，我是免费搭建查券返利机器人省钱赚佣金就用微赚淘客系统3.0的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！今天我们将深入探讨在Java应用程序中如何实现高效的缓存机制。缓存是提高应用程序性能的重要手段之一，通过将频繁访问的数据存储在内存中，减少对数据库或外部服务的访问次数，从而加速数据访问和提升系统响应速度。本文将介绍Java中实现缓存的各种方法和技术，帮助你在实际项目中应用缓存来优化性能。
Java本地高性能缓存的几种实现方式
热门推荐
吴名氏的博客
12-01 14万+
Java本地高性能缓存的几种实现方式
Java缓存技术总结
hebeind100的博客
05-14 527
1缓存为什么要存在? 2缓存可以存在于什么地方? 3缓存有哪些属性? 4缓存介质，及其优缺点 5Java本地缓存设计及实现   搞清楚这4个问题,那么我们就可以随意的通过应用的场景来判断使用何种缓存了.     1. 缓存为什么要存在? 一 般情况下,一个网站,或者一个应用,它的一般形式是,浏览器请求应用服务器,应用服务器做一堆计算后再请求数据库,数据库收到请求后再作一堆计算...
讲述java中常见的几种缓存数据形式 并简单演示
weixin_45966674的博客
10-17 1664
ConcurrentHashMap 没有自动过期的设置 所以想让他自己过期你要自己写逻辑处理，然后他的消失情况除了项目停止运行之外还有就是当内存不足时系统操作会回收一些内存，就可能导致部分ConcurrentHashMap被回收。它使用分段锁来提高并发性能，不同的线程可以同时访问不同的分段，从而提高并发访问的效率。Caffeine有过期时间的设置，当达到时间则消失 内存超出时也会回收一定的Caffeine，当达到设置的大小之后Caffeine也会按照依据移除一些缓存 然后就是可以手动删除。
java缓存技术.ppt
03-18
java缓存技术.ppt
java缓存技术
09-14
下面我们将深入探讨Java缓存技术，特别是Ehcache的使用。 首先，理解缓存的基本原理至关重要。缓存是一种存储技术，用于临时存储最近或最常访问的数据，以便快速访问。在Java应用中，缓存可以减少对远程服务（如...
Java缓存技术
10-24
关于Java缓存技术方面的期刊
Java缓存技术总结初见
06-15
本文将简要介绍缓存的基本概念，分析其优缺点，并探讨几种常见的Java缓存技术。 1、缓存是什么？ 缓存是一种技术手段，用于临时存储经常访问或计算的数据，以减少不必要的重复计算和I/O操作，从而提高系统的响应...
java map 实现缓存技术
04-03
本文将深入探讨如何使用Java Map实现缓存技术，以及其中的关键知识点。 首先，让我们理解什么是缓存。缓存是一种存储技术，用于暂时保存经常访问的数据，以便于快速检索。在Java中，我们通常使用HashMap、...
java缓存详解
yushan125的博客
03-25 3075
缓存
java比较常用的缓存技术_常用缓存技术
weixin_42161497的博客
02-27 2646
热数据缓存这是使用缓存最频繁最直接的方式，即我们把需要频繁访问DB的数据加载到内存里面，以提高响应速度。通常我们的做法是使用一个ConcuccrentHashMap来记录一天当中每个请求的次数，每天凌晨取出昨天访问最频繁的K个请求(K取多少个取决你的可用内存有多少)，从DB中读取这些请求的返回结果放到一个ConcuccrentHashMap容器中，然后把所有请求计数清0，重新开始计数。LRU缓存热...
JAVA缓存机制浅析
yuhang的博客
09-19 981
一.缓存是什么？ 1、Cache是高速缓冲存储器 一种特殊的存储器子系统，其中复制了频繁使用的数据以利于快速访问 2、凡是位于速度相差较大的两种硬件/软件之间的，用于协调两者数据传输速度差异的结构，均可称之为 Cache 二.缓存分类 1、在系统架构的不同层级之间，为了加快访问速度，都可以存在缓存 操作系统磁盘缓存->减少磁盘机械操作 数据库缓存->减少文件系统I/O 应用程序缓存->减少对数据库的查询 Web服务器缓存->减少应用服务器请求 客户端浏览器缓存-&g.
Java实现一个简单的缓存
brightloong的博客
07-26 4万+
cache 阅读原文请访问我的博客BrightLoong's Blog  缓存是在web开发中经常用到的，将程序经常使用到或调用到的对象存在内存中，或者是耗时较长但又不具有实时性的查询数据放入内存中，在一定程度上可以提高性能和效率。下面我实现了一个简单的缓存，步骤如下。 创建缓存对象EntityCache.java public class EntityCache { /** *
JAVA缓存技术
codermouse的博客
05-27 263
最近再ITEYE上看到关于讨论JAVA缓存技术的帖子比较多，自己不懂，所以上网大概搜了下，找到一篇，暂作保存，后面如果有用到可以参考。此为转贴，帖子来处:http://cogipard.info/articles/cache-static-files-with-jnotify-and-ehcache 介绍 JNotify：http://jnotify.sourceforge.net/，通过...
JAVA缓存技术：提升Web应用性能的关键策略
Java缓存技术在现代Web开发中扮演着关键角色，旨在提升网站性能、减少数据库访问压力以及优化资源使用。本文将深入探讨缓存技术的基本概念、在Web应用架构中的作用以及不同类型的缓存策略。 首先，缓存是一种高速...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值