Java 高并发缓存与Guava Cache

女爷i 2022-06-11 09:24 197阅读 0赞

非常感谢  [http://blog.csdn.net/congcong68/article/details/41146295][http_blog.csdn.net_congcong68_article_details_41146295]

**缓存技术学习 [https://www.itkc8.com][https_www.itkc8.com]**

**一.背景**

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

（1）本地缓存。

（2）[数据库][Link 1]缓存。

（3）分布式缓存。

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

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

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

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

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

**\[java\]** [view plain][] [copy][view plain]

1.  **public** **class** TestConcurrentHashMapCache<K,V> \{  
2.      **private** **final** ConcurrentHashMap<K, V>  cacheMap=**new** ConcurrentHashMap<K,V> ();   
3.        
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.     \}  
15.       
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.     \}  
25.   
26.       
27.       
28.     **public** **static** **void** main(String\[\] args) \{  
29.         **final** TestConcurrentHashMapCache<String,String> TestGuaVA=**new** TestConcurrentHashMapCache<String,String>();  
30.           
31.         Thread t1=**new** Thread(**new** Runnable() \{  
32.             @Override  
33.             **public** **void** run() \{  
34.                   
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========");  
39.                   
40.             \}  
41.         \});  
42.           
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========");  
50.                   
51.             \}  
52.         \});  
53.           
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========");  
61.                   
62.             \}  
63.         \});  
64.           
65.         t1.start();  
66.         t2.start();  
67.         t3.start();  
68.   
69.     \}  
70.   
71. \}

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

![outside_default.png][]

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

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

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

**   第二种：**

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

**\[java\]** [view plain][] [copy][view plain]

1.  **public** **class** TestConcurrentHashMapCache<K,V> \{  
2.      **private** **final** ConcurrentHashMap<K, V>  cacheMap=**new** ConcurrentHashMap<K,V> ();   
3.        
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.     \}  
15.       
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.     \}  
25.   
26.       
27.       
28.     **public** **static** **void** main(String\[\] args) \{  
29.         **final** TestConcurrentHashMapCache<String,String> TestGuaVA=**new** TestConcurrentHashMapCache<String,String>();  
30.           
31.         Thread t1=**new** Thread(**new** Runnable() \{  
32.             @Override  
33.             **public** **void** run() \{  
34.                   
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========");  
39.                   
40.             \}  
41.         \});  
42.           
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========");  
50.                   
51.             \}  
52.         \});  
53.           
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========");  
61.                   
62.             \}  
63.         \});  
64.           
65.         t1.start();  
66.         t2.start();  
67.         t3.start();  
68.   
69.     \}  
70.   
71. \}

执行结果，如图所示：

![outside_default.png][]

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

**第三种：**

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

**\[java\]** [view plain][] [copy][view plain]

1.  **public** **class** TestFutureCahe<K,V> \{  
2.      **private** **final** ConcurrentHashMap<K, Future<V>>  cacheMap=**new** ConcurrentHashMap<K, Future<V>> ();   
3.        
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();  
16.                   
17.         \}**catch** (Exception e) \{  
18.         \}  
19.         **return** **null**;  
20.     \}  
21.       
22.       
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.     \}  
43.       
44.       
45.   
46.       
47.       
48.     **public** **static** **void** main(String\[\] args) \{  
49.         **final** TestFutureCahe<String,String> TestGuaVA=**new** TestFutureCahe<String,String>();  
50.           
51.         Thread t1=**new** Thread(**new** Runnable() \{  
52.             @Override  
53.             **public** **void** run() \{  
54.                   
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========");  
59.                   
60.             \}  
61.         \});  
62.           
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========");  
70.                   
71.             \}  
72.         \});  
73.           
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========");  
81.                   
82.             \}  
83.         \});  
84.           
85.         t1.start();  
86.         t2.start();  
87.         t3.start();  
88.   
89.     \}  
90.   
91. \}

线程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能设置回收，能解决在[大数据][Link 2]内存溢出的问题，源代码如下：

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)：监听事件，在元素被删除时，进行监听。

执行结果，如图所示：

![outside_default.png][]

**缓存技术学习 [https://www.itkc8.com][https_www.itkc8.com]**

[http_blog.csdn.net_congcong68_article_details_41146295]: http://blog.csdn.net/congcong68/article/details/41146295
[https_www.itkc8.com]: https://www.itkc8.com
[Link 1]: http://lib.csdn.net/base/mysql
[Java]: http://lib.csdn.net/base/java
[view plain]: http://blog.csdn.net/congcong68/article/details/41146295#
[outside_default.png]: /images/20220611/2951f7ae650a4a56ae1e511c225819ce.png
[Link 2]: http://lib.csdn.net/base/hadoop