Java 高并发缓存与Guava Cache

最新推荐文章于 2024-05-01 21:35:39 发布
最新推荐文章于 2024-05-01 21:35:39 发布
阅读量1.7w 收藏 10
点赞数 3

一.背景

缓存是我们在开发中为了提高系统的性能，把经常的访问业务的数据第一次把处理结果先放到缓存中，第二次就不用在对相同的业务数据在重新处理一遍，这样就提高了系统的性能。缓存分好几种：

（1）本地缓存。

（2）数据库缓存。

（3）分布式缓存。

分布式缓存比较常用的有memcached等，memcached是高性能的分布式内存缓存服务器，缓存业务处理结果，减少数据库访问次数和相同复杂逻辑处理的时间，以提高动态Web应用的速度、 提高可扩展性。

二.本地缓存在高并发下的问题以及解决

今天我们介绍的是本地缓存缓存，我们这边采用java.util.concurrent.ConcurrentHashMap来保存，ConcurrentHashMap是一个线程安全的HashTable，并提供了一组和HashTable功能相同但是线程安全的方法，ConcurrentHashMap可以做到读取数据不加锁，提高了并发能力。我们先不考虑内存元素回收或者在保存数据会出现内存溢出的情况，我们用ConcurrentHashMap模拟本地缓存，当在高并发环境一下，会出现一些什么问题？


我们这边采用实现多个线程来模拟高并发场景。


第一种：我们先来看一下代码：


[java] view plain copy print ?
  1. public class TestConcurrentHashMapCache<K,V> {
  2. private final ConcurrentHashMap<K, V> cacheMap=new ConcurrentHashMap<K,V> ();
  4. public Object getCache(K keyValue,String ThreadName){
  5. System.out.println("ThreadName getCache=============="+ThreadName);
  6. Object value=null;
  7. //从缓存获取数据
  8. value=cacheMap.get(keyValue);
  9. //如果没有的话，把数据放到缓存
  10. if(value==null){
  11. return putCache(keyValue,ThreadName);
  12. }
  13. return value;
  14. }
  16. public Object putCache(K keyValue,String ThreadName){
  17. System.out.println("ThreadName 执行业务数据并返回处理结果的数据（访问数据库等）=============="+ThreadName);
  18. //可以根据业务从数据库获取等取得数据,这边就模拟已经获取数据了
  19. @SuppressWarnings("unchecked")
  20. V value=(V) "dataValue";
  21. //把数据放到缓存
  22. cacheMap.put(keyValue, value);
  23. return value;
  24. }
  28. public static void main(String[] args) {
  29. final TestConcurrentHashMapCache<String,String> TestGuaVA=new TestConcurrentHashMapCache<String,String>();
  31. Thread t1=new Thread(new Runnable() {
  32. @Override
  33. public void run() {
  35. System.out.println("T1======start========");
  36. Object value=TestGuaVA.getCache("key","T1");
  37. System.out.println("T1 value=============="+value);
  38. System.out.println("T1======end========");
  40. }
  41. });
  43. Thread t2=new Thread(new Runnable() {
  44. @Override
  45. public void run() {
  46. System.out.println("T2======start========");
  47. Object value=TestGuaVA.getCache("key","T2");
  48. System.out.println("T2 value=============="+value);
  49. System.out.println("T2======end========");
  51. }
  52. });
  54. Thread t3=new Thread(new Runnable() {
  55. @Override
  56. public void run() {
  57. System.out.println("T3======start========");
  58. Object value=TestGuaVA.getCache("key","T3");
  59. System.out.println("T3 value=============="+value);
  60. System.out.println("T3======end========");
  62. }
  63. });
  65. t1.start();
  66. t2.start();
  67. t3.start();
  69. }
  71. } 
public class TestConcurrentHashMapCache<K,V> {
	private final ConcurrentHashMap<K, V>  cacheMap=new ConcurrentHashMap<K,V> (); 
	
	public  Object getCache(K keyValue,String ThreadName){
		System.out.println("ThreadName getCache=============="+ThreadName);
		Object value=null;
		//从缓存获取数据
		value=cacheMap.get(keyValue);
		//如果没有的话，把数据放到缓存
		if(value==null){
			return putCache(keyValue,ThreadName);
		}
		return value;
	}
	
	public Object putCache(K keyValue,String ThreadName){
		System.out.println("ThreadName 执行业务数据并返回处理结果的数据（访问数据库等）=============="+ThreadName);
		//可以根据业务从数据库获取等取得数据,这边就模拟已经获取数据了
		@SuppressWarnings("unchecked")
		V value=(V) "dataValue";
		//把数据放到缓存
		 cacheMap.put(keyValue, value);
		return value;
	}

	
	
	public static void main(String[] args) {
		final TestConcurrentHashMapCache<String,String> TestGuaVA=new TestConcurrentHashMapCache<String,String>();
		
		Thread t1=new Thread(new Runnable() {
			@Override
			public void run() {
				
				System.out.println("T1======start========");
			    Object value=TestGuaVA.getCache("key","T1");
			    System.out.println("T1 value=============="+value);
				System.out.println("T1======end========");
				
			}
		});
		
		Thread t2=new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("T2======start========");
				Object value=TestGuaVA.getCache("key","T2");
			    System.out.println("T2 value=============="+value);
				System.out.println("T2======end========");
				
			}
		});
		
		Thread t3=new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("T3======start========");
				Object value=TestGuaVA.getCache("key","T3");
			    System.out.println("T3 value=============="+value);
				System.out.println("T3======end========");
				
			}
		});
		
		t1.start();
		t2.start();
		t3.start();

	}

}
我们看一下执行结果，如图所示：

我们实现了本地缓存代码，我们执行一下结果，发现在多线程时，出现了在缓存里没有缓存时，会执行一样执行多次的业务数据并返回处理的数据，我们分析一下出现这种情况的：

（1）当线程T1访问cacheMap里面有没有，这时根据业务到后台处理业务数据并返回处理数据，并放入缓存。

（2）当线程T2访问cacheMap里面同样也没有，也把根据业务到后台处理业务数据并返回处理数据，并放入缓存。

第二种：

这样相同的业务并处理两遍，如果在高并发的情况下相同的业务不止执行两遍，这样这样跟我们当初做缓存不相符合，这时我们想到了Java多线程时，在执行获取缓存上加上Synchronized，代码如下：

[java] view plain copy print ?
  1. public class TestConcurrentHashMapCache<K,V> {
  2. private final ConcurrentHashMap<K, V> cacheMap=new ConcurrentHashMap<K,V> ();
  4. public <span style="color:#ff0000;">synchronized </span>Object getCache(K keyValue,String ThreadName){
  5. System.out.println("ThreadName getCache=============="+ThreadName);
  6. Object value=null;
  7. //从缓存获取数据
  8. value=cacheMap.get(keyValue);
  9. //如果没有的话，把数据放到缓存
  10. if(value==null){
  11. return putCache(keyValue,ThreadName);
  12. }
  13. return value;
  14. }
  16. public Object putCache(K keyValue,String ThreadName){
  17. System.out.println("ThreadName 执行业务数据并返回处理结果的数据（访问数据库等）=============="+ThreadName);
  18. //可以根据业务从数据库获取等取得数据,这边就模拟已经获取数据了
  19. @SuppressWarnings("unchecked")
  20. V value=(V) "dataValue";
  21. //把数据放到缓存
  22. cacheMap.put(keyValue, value);
  23. return value;
  24. }
  28. public static void main(String[] args) {
  29. final TestConcurrentHashMapCache<String,String> TestGuaVA=new TestConcurrentHashMapCache<String,String>();
  31. Thread t1=new Thread(new Runnable() {
  32. @Override
  33. public void run() {
  35. System.out.println("T1======start========");
  36. Object value=TestGuaVA.getCache("key","T1");
  37. System.out.println("T1 value=============="+value);
  38. System.out.println("T1======end========");
  40. }
  41. });
  43. Thread t2=new Thread(new Runnable() {
  44. @Override
  45. public void run() {
  46. System.out.println("T2======start========");
  47. Object value=TestGuaVA.getCache("key","T2");
  48. System.out.println("T2 value=============="+value);
  49. System.out.println("T2======end========");
  51. }
  52. });
  54. Thread t3=new Thread(new Runnable() {
  55. @Override
  56. public void run() {
  57. System.out.println("T3======start========");
  58. Object value=TestGuaVA.getCache("key","T3");
  59. System.out.println("T3 value=============="+value);
  60. System.out.println("T3======end========");
  62. }
  63. });
  65. t1.start();
  66. t2.start();
  67. t3.start();
  69. }
  71. } 
public class TestConcurrentHashMapCache<K,V> {
	private final ConcurrentHashMap<K, V>  cacheMap=new ConcurrentHashMap<K,V> (); 
	
	public <span style="color:#ff0000;">synchronized </span>Object getCache(K keyValue,String ThreadName){
		System.out.println("ThreadName getCache=============="+ThreadName);
		Object value=null;
		//从缓存获取数据
		value=cacheMap.get(keyValue);
		//如果没有的话，把数据放到缓存
		if(value==null){
			return putCache(keyValue,ThreadName);
		}
		return value;
	}
	
	public Object putCache(K keyValue,String ThreadName){
		System.out.println("ThreadName 执行业务数据并返回处理结果的数据（访问数据库等）=============="+ThreadName);
		//可以根据业务从数据库获取等取得数据,这边就模拟已经获取数据了
		@SuppressWarnings("unchecked")
		V value=(V) "dataValue";
		//把数据放到缓存
		 cacheMap.put(keyValue, value);
		return value;
	}

	
	
	public static void main(String[] args) {
		final TestConcurrentHashMapCache<String,String> TestGuaVA=new TestConcurrentHashMapCache<String,String>();
		
		Thread t1=new Thread(new Runnable() {
			@Override
			public void run() {
				
				System.out.println("T1======start========");
			    Object value=TestGuaVA.getCache("key","T1");
			    System.out.println("T1 value=============="+value);
				System.out.println("T1======end========");
				
			}
		});
		
		Thread t2=new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("T2======start========");
				Object value=TestGuaVA.getCache("key","T2");
			    System.out.println("T2 value=============="+value);
				System.out.println("T2======end========");
				
			}
		});
		
		Thread t3=new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("T3======start========");
				Object value=TestGuaVA.getCache("key","T3");
			    System.out.println("T3 value=============="+value);
				System.out.println("T3======end========");
				
			}
		});
		
		t1.start();
		t2.start();
		t3.start();

	}

}
执行结果，如图所示：

这样就实现了串行，在高并发行时，就不会出现了第二个访问相同业务，肯定是从缓存获取，但是加上Synchronized变成串行，这样在高并发行时性能也下降了。

第三种：

我们为了实现性能和缓存的结果，我们采用Future，因为Future在计算完成时获取，否则会一直阻塞直到任务转入完成状态和ConcurrentHashMap.putIfAbsent方法，代码如下：

[java] view plain copy print ?
  1. public class TestFutureCahe<K,V> {
  2. private final ConcurrentHashMap<K, Future<V>> cacheMap=new ConcurrentHashMap<K, Future<V>> ();
  4. public Object getCache(K keyValue,String ThreadName){
  5. Future<V> value=null;
  6. try{
  7. System.out.println("ThreadName getCache=============="+ThreadName);
  8. //从缓存获取数据
  9. value=cacheMap.get(keyValue);
  10. //如果没有的话，把数据放到缓存
  11. if(value==null){
  12. value= putCache(keyValue,ThreadName);
  13. return value.get();
  14. }
  15. return value.get();
  17. }catch (Exception e) {
  18. }
  19. return null;
  20. }
  23. public Future<V> putCache(K keyValue,final String ThreadName){
  24. // //把数据放到缓存
  25. Future<V> value=null;
  26. Callable<V> callable=new Callable<V>() {
  27. @SuppressWarnings("unchecked")
  28. @Override
  29. public V call() throws Exception {
  30. //可以根据业务从数据库获取等取得数据,这边就模拟已经获取数据了
  31. System.out.println("ThreadName 执行业务数据并返回处理结果的数据（访问数据库等）=============="+ThreadName);
  32. return (V) "dataValue";
  33. }
  34. };
  35. FutureTask<V> futureTask=new FutureTask<V>(callable);
  36. value=cacheMap.putIfAbsent(keyValue, futureTask);
  37. if(value==null){
  38. value=futureTask;
  39. futureTask.run();
  40. }
  41. return value;
  42. }
  48. public static void main(String[] args) {
  49. final TestFutureCahe<String,String> TestGuaVA=new TestFutureCahe<String,String>();
  51. Thread t1=new Thread(new Runnable() {
  52. @Override
  53. public void run() {
  55. System.out.println("T1======start========");
  56. Object value=TestGuaVA.getCache("key","T1");
  57. System.out.println("T1 value=============="+value);
  58. System.out.println("T1======end========");
  60. }
  61. });
  63. Thread t2=new Thread(new Runnable() {
  64. @Override
  65. public void run() {
  66. System.out.println("T2======start========");
  67. Object value=TestGuaVA.getCache("key","T2");
  68. System.out.println("T2 value=============="+value);
  69. System.out.println("T2======end========");
  71. }
  72. });
  74. Thread t3=new Thread(new Runnable() {
  75. @Override
  76. public void run() {
  77. System.out.println("T3======start========");
  78. Object value=TestGuaVA.getCache("key","T3");
  79. System.out.println("T3 value=============="+value);
  80. System.out.println("T3======end========");
  82. }
  83. });
  85. t1.start();
  86. t2.start();
  87. t3.start();
  89. }
  91. } 
public class TestFutureCahe<K,V> {
	private final ConcurrentHashMap<K, Future<V>>  cacheMap=new ConcurrentHashMap<K, Future<V>> (); 
	
	public   Object getCache(K keyValue,String ThreadName){
		Future<V> value=null;
		try{
			System.out.println("ThreadName getCache=============="+ThreadName);
			//从缓存获取数据
			value=cacheMap.get(keyValue);
			//如果没有的话，把数据放到缓存
			if(value==null){
				value= putCache(keyValue,ThreadName);
				return value.get();
			}
			return value.get();
				
		}catch (Exception e) {
		}
		return null;
	}
	
	
	public Future<V> putCache(K keyValue,final String ThreadName){
//		//把数据放到缓存
		Future<V> value=null;
		Callable<V> callable=new Callable<V>() {
				@SuppressWarnings("unchecked")
				@Override
				public V call() throws Exception {
					//可以根据业务从数据库获取等取得数据,这边就模拟已经获取数据了
					System.out.println("ThreadName 执行业务数据并返回处理结果的数据（访问数据库等）=============="+ThreadName);
					return (V) "dataValue";
				}
			};
			FutureTask<V> futureTask=new FutureTask<V>(callable);
			value=cacheMap.putIfAbsent(keyValue, futureTask);
			if(value==null){
				value=futureTask;
				futureTask.run();
			}
		return value;
	}
	
	

	
	
	public static void main(String[] args) {
		final TestFutureCahe<String,String> TestGuaVA=new TestFutureCahe<String,String>();
		
		Thread t1=new Thread(new Runnable() {
			@Override
			public void run() {
				
				System.out.println("T1======start========");
				Object value=TestGuaVA.getCache("key","T1");
				System.out.println("T1 value=============="+value);
				System.out.println("T1======end========");
				
			}
		});
		
		Thread t2=new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("T2======start========");
				Object value=TestGuaVA.getCache("key","T2");
				System.out.println("T2 value=============="+value);
				System.out.println("T2======end========");
				
			}
		});
		
		Thread t3=new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("T3======start========");
				Object value=TestGuaVA.getCache("key","T3");
				System.out.println("T3 value=============="+value);
				System.out.println("T3======end========");
				
			}
		});
		
		t1.start();
		t2.start();
		t3.start();

	}

}

线程T1或者线程T2访问cacheMap，如果都没有时，这时执行了FutureTask来完成异步任务，假如线程T1执行了FutureTask，并把保存到ConcurrentHashMap中，通过PutIfAbsent方法，因为putIfAbsent方法如果不存在key对应的值，则将value以key加入Map，否则返回key对应的旧值。这时线程T2进来时可以获取Future对象，如果没值没关系，这时是对象的引用，等FutureTask执行完，在通过get返回。

我们问题解决了高并发访问缓存的问题，可以回收元素这些，都没有，容易造成内存溢出，Google Guava Cache在这些问题方面都做得挺好的，接下来我们介绍一下。

三.Google Guava Cache的介绍和应用



http://www.java2s.com/Code/Jar/g/Downloadguava1401jar.htm 下载对应的jar包


Guava Cache与ConcurrentMap很相似，Guava Cache能设置回收，能解决在大数据内存溢出的问题，源代码如下：



public class TestGuaVA<K,V> {
private Cache<K, V> cache= CacheBuilder.newBuilder() .maximumSize(2).expireAfterWrite(10, TimeUnit.MINUTES).build();
public Object getCache(K keyValue,final String ThreadName){
Object value=null;
try {
System.out.println("ThreadName getCache=============="+ThreadName);
//从缓存获取数据
value = cache.get(keyValue, new Callable<V>() {
@SuppressWarnings("unchecked")
public V call() {
System.out.println("ThreadName 执行业务数据并返回处理结果的数据（访问数据库等）=============="+ThreadName);
return (V) "dataValue";
}
});
} catch (ExecutionException e) {
e.printStackTrace();
}
return value;
}





public static void main(String[] args) {
final TestGuaVA<String,String> TestGuaVA=new TestGuaVA<String,String>();


Thread t1=new Thread(new Runnable() {
@Override
public void run() {

System.out.println("T1======start========");
Object value=TestGuaVA.getCache("key","T1");
System.out.println("T1 value=============="+value);
System.out.println("T1======end========");

}
});

Thread t2=new Thread(new Runnable() {
@Override
public void run() {
System.out.println("T2======start========");
Object value=TestGuaVA.getCache("key","T2");
System.out.println("T2 value=============="+value);
System.out.println("T2======end========");

}
});

Thread t3=new Thread(new Runnable() {
@Override
public void run() {
System.out.println("T3======start========");
Object value=TestGuaVA.getCache("key","T3");
System.out.println("T3 value=============="+value);
System.out.println("T3======end========");

}
});

t1.start();
t2.start();
t3.start();


}


}


说明：

CacheBuilder.newBuilder()后面能带一些设置回收的方法：

（1）maximumSize(long)：设置容量大小，超过就开始回收。

（2）expireAfterAccess(long, TimeUnit)：在这个时间段内没有被读/写访问，就会被回收。

（3）expireAfterWrite(long, TimeUnit)：在这个时间段内没有被写访问，就会被回收 。

(4)removalListener(RemovalListener)：监听事件，在元素被删除时，进行监听。

执行结果，如图所示：


Michaelwubo
关注
  • 3
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
高并发缓存器（基于ehcache）
08-23
跟博客中的高并发缓存器对应的代码，主要是基于ehcache进行代码整合，同时容器附带一些更新器的功能
高并发之——Guava Cache
冰河的专栏
10-27 6162
最近需要用到缓存来存放临时数据，又不想采用Redis，Java自带的Map功能太少，发现Google的Guava提供的Cache模块功能很强大，于是选择使用它。 本地缓存 本地缓存作用就是提高系统的运行速度，是一种空间换时间的取舍。它实质上是一个做key-value查询的字典，但是相对于我们常用HashMap它又有以下特点： 1.并发性：由于目前的应用大都是多线程的，所以缓存需要支持并发的写...
缓存分享(1)——Guava Cache原理及最佳实践
最新发布
麦田里的码农
05-01 2010
Guava Cache最佳实践
高并发之--Guava Cache
zhangge3663的博客
07-28 579
最近需要用到缓存来存放临时数据，又不想采用Redis，Java自带的Map功能太少，发现google的Guava提供的Cache模块功能很强大，于是选择使用它。 本地缓存 本地缓存作用就是提高系统的运行速度，是一种空间换时间的取舍。它实质上是一个做key-value查询的字典，但是相对于我们常用的HashMap它又有以下特点: 1.并发性: 由于目前的应用大都是多线程的，所以缓存需要支持并发的写入。 2.过期策略:在某些场景中，我们可能会希望缓存的数据有一定"保质期",过期策略可以固定时间，例如缓存
guava cache缓存组件在并发场景下的问题
Fake_Armour
01-25 2108
前言 去年面蚂蚁的时候，二面提到自己项目里使用了guava cache来缓存一些高频读的配置文件，被问到了它的实现以及并发场景下可能存在什么问题，因为没有深入了解过，所以没回答上来。现在想来除了技术上的问题之外，也反映了当时我个人的思考不够的问题： 1 在对基础组件原理完全不了解的情况下就盲目使用，是否会因此带来一些隐藏的坑； 2 为什么没有抽时间去对用到的技术栈做一下简单的了解和调研，做出这样的技术选型的背景和理由根本讲不出来。 常常说要积累技术的广度和深度，就是应该要在这些地方多思考才行。想起之前一个组
Java Cache系列之Guava Cache
kobejayandy的专栏
10-28 3201
Guava作为Google开源出来的工具库，Google自己对Guava的描述：The Guava project contains several of Google's core libraries that we rely on in our Java-based projects: collections, caching, primitives support, concurrency
guava-cache.rar
04-05
尽管分布式缓存如Redis在高并发和大规模场景下表现出色，但本地缓存在某些情况下仍然具有不可忽视的优势，例如低延迟、无网络开销以及对实时性要求高的场景。 Guava Cache的设计目标是简化缓存管理，并提供自动过期...
Java高并发高性能分布式框架从无到有微服务架构设计.doc
11-15
Java 高并发高性能分布式框架从无到有微服务架构设计 微服务架构模式（Microservice Architect Pattern）是当前热门的架构模式之一，它提倡将单一应用程序划分成一组小的服务，服务之间互相协调、互相配合，为用户...
java map 实现缓存技术
04-03
在许多实际应用中，尤其是高性能和高并发的场景，Map常被用来实现缓存技术，以提高数据读取速度和系统性能。本文将深入探讨如何使用Java Map实现缓存技术，以及其中的关键知识点。 首先，让我们理解什么是缓存。...
cache设置缓存数据，可直接运行
10-12
7. **分布式缓存**：在高并发的场景下，单机缓存可能无法满足需求，这时会采用分布式缓存，如Redis。分布式缓存能够提供更强大的扩展性和高可用性，确保在多台服务器间共享数据，并且能够在某台服务器故障时仍能正常...
java缓存工具 SimpleCache_java_缓存_
10-04
5. **扩展性**：作为一个优秀的缓存工具，SimpleCache 可能允许用户自定义缓存实现，或者与其他缓存解决方案（如 Ehcache、Guava Cache）集成。 6. **缓存失效通知**：当缓存中的数据被更新或删除时，SimpleCache ...
Java 高并发缓存与Guava Cache
在前进的路上
11-15 2万+
今天我们介绍的是本地缓存缓存，我们这边采用java.util.concurrent.ConcurrentHashMap来保存，ConcurrentHashMap是一个线程安全的HashTable，并提供了一组和HashTable功能相同但是线程安全的方法，ConcurrentHashMap可以做到读取数据不加锁，提高了并发能力。我们先不考虑内存元素回收或者在保存数据会出现内存溢出的情况，我们用ConcurrentHashMap模拟本地缓存，当在高并发环境一下，会出现一些什么问题？
对Guava Cache的封装和使用（包括一个管理页面实现了查看统计信息、情况、查看记录等）
Clement-Xu的专栏
06-14 1万+
由于项目的实际情况，需要缓存一些比较不经常改动的数据在本地服务器中，以提高接口处理的速度。决定采用Guava Cache。现在，该系统已经实现，并已经在正式环境中运行了一段时间，日均总命中次数超过一百万，大部分缓存的命中率在98%以上，为某些接口的请求节省了一半的时间。本文介绍具体的实现详情。
Guava Cache 使用学习
热门推荐
汪小哥
02-05 5万+
Guava -Caache Guava缓存值CacheBuilder介绍-参考 Google -CachesExplained wiki 缓存框架Guava Cache部分源码分析 概述 缓存是日常开发中经常应用到的一种技术手段，合理的利用缓存可以极大的改善应用程序的性能。 Guava官方对Cache的描述连接 缓存在各种各样的用例中非常有用。例如，当计算或检索值很昂贵时，您应
Ehcache与Guava Cache的介绍
lusteiger的博客
12-06 3116
Ehcache是一个用Java实现的使用简单，告诉，线程安全的缓存管理类库。Ehcache具有快速、简单、低消耗、依赖性小等特点，遵循Apache 2.0 license。官网http://www.ehcache.org/ 主要特点 快速，简单 过去众多测试已经证明Ehcache是最快的Java缓存之一，Ehcache的线程机制是为大型高并发系统设计的，不需要复杂的配置，API也已于使用，很容易...
Java缓存技术-google guava cache
Y-CAT的专栏
01-09 4643
一、简介 guava和ehcache一样也是本地缓存，虽然都是本地缓存，但是有着不同的使用场景。guava是谷歌提供的一个Java工具包，而Guava的Cache部分提供了一套分词完善的本地存储缓存机制，在Guave之前ConcurrentMap，因为能友好的支持并发而经常被用作本地缓存，但它毕竟不具备缓存的一些特性，比如缓存过期，缓存数据加载和刷新等。   二、使用场景 1、原意消耗一些
Guava Cache用法介绍
weixin_33814685的博客
09-11 1042
Guava Cache是在内存中缓存数据，相比较于数据库或redis存储，访问内存中的数据会更加高效。Guava官网介绍，下面的这几种情况可以考虑使用Guava Cache： 愿意消耗一些内存空间来提升速度。 预料到某些键会被多次查询。 缓存中存放的数据总量不会超出内存容量。 所以，可以将程序频繁用到的少量数据存储到Guava Cac...
Java Guava Cache 使用2021-07-12
qq_34874784的博客
07-12 228
maven 依赖 <dependency> <groupId>#com.google.guava</groupId> <artifactId>guava</artifactId> <version>30.1-jre</version> </dependency> 初始化 LoadingCache<String, Employee> cache = CacheBuild
【Java】Guava学习：Cache缓存入门
然后微微笑的博客
04-17 344
摘要: 学习Google内部使用的工具包Guava，在Java项目中轻松地增加缓存，提高程序获取数据的效率。 一、什么是缓存？ 根据科普中国的定义，缓存就是数据交换的缓冲区（称作Cache），当某一硬件要读取数据时，会首先从缓存中查找需要的数据，如果找到了则直接执行，找不到的话则从内存中找。由于缓存的运行速度比内存快得多，故缓存的作用就是帮助硬件更快地运行。 在这里，我们借用了硬件缓存的概念，...
高并发系统中缓存的利用和分析.pptx
12-27
"该资源为一个关于高并发系统中缓存利用和分析的PPT，主要探讨了如何在高并发场景下优化缓存策略以提高系统性能。内容涵盖了多级缓存架构，包括浏览器本地缓存、LVS、Nginx、lua脚本、Redis以及堆外缓存等，强调了...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值