并发编程系列之JDK JUC实现内存缓存（支持并发）

在 Java 5.0 提供了 java.util.concurrent(简称JUC)包,在此包中增加了在并发编程中很常用的工具类,
用于定义类似于线程的自定义子系统,包括线程池,异步 IO 和轻量级任务框架;还提供了设计用于多线程上下文中
的 Collection 实现等;

业务：利用jdk JUC， java.util.concurrent里的类实现定时缓存，缓存可以设置过期，过期可以定时清缓存。对于业务数据来说，如果缓存有数据，就直接读缓存（内存），缓存没数据才读数据库，读取之后要将数据再丢到缓存，代码参考：

ps：本代码例子比较简单，只适合业务比较简单的数据缓存，主要是通过ConcurrentMap保证线程安全，ScheduledExecutorService用于创建定时线程池

import com.extra.login.cas.client.util.CasParamKeyEnum;
import com.extra.login.cas.client.util.CasPropertiesLoader;
import com.common.utils.ApplicationContextHolder;
import com.webConfig.service.WebConfigService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.*;

/**
 * <pre>
 * 获取配置数据，并加上local缓存
 * </pre>
 *
 * <pre>
 * @author mazq
 * 修改记录
 * 修改后版本: 修改人：  修改日期: 2020/08/26 16:59  修改内容:
 * </pre>
 */
@Component
public class FilterCondition { Logger LOG = LoggerFactory.getLogger(FilterCondition.class); private static String CACHE_KEY = "CAS_LOGIN_MODE";
// private static int EXPIRE = 24 * 60 * 60 * 1000; private static int EXPIRE = Integer.parseInt(CasPropertiesLoader.getValue(CasParamKeyEnum.CACHE_LOCALE_EXPIRE.getCasParamKey())); /** *  读取配置数据，加上缓存 * @Author mazq * @Date 2020/09/07 17:52 * */ public static boolean isCasLoginMode() { WebConfigService webConfigService = (WebConfigService) ApplicationContextHolder.getApplicationContext().getBean("webConfigService"); Boolean casModeFlagCache = CacheManager.get(CACHE_KEY , Boolean.class); if (casModeFlagCache != null) { // 缓存有数据，返回缓存 return casModeFlagCache; } casModeFlagCache = webConfigService.getConfigFlag("${hzCasLogin_Boolean}");// 缓存没数据，重现读取数据库 CacheManager.put(CACHE_KEY, casModeFlagCache, EXPIRE); // 将数据库数据再丢到缓存 return casModeFlagCache; } static class CacheManager { private static ConcurrentMap<String, CacheWrapper> CACHE; private static ScheduledExecutorService executor;// 定时器线程池 static { CACHE = new ConcurrentHashMap<String, CacheWrapper>(); executor = Executors.newSingleThreadScheduledExecutor(); } public static void put(String key, Object data) { put(key, data, 0); } public static void put(final String key, Object value, int expire) { CACHE.remove(key);// 将原来的缓存数据先remove if (expire > 0) { // 有配置expire Future future = executor.schedule(new Runnable() { @Override public void run() { CACHE.remove(key); } }, expire, TimeUnit.MILLISECONDS); CACHE.put(key, new CacheWrapper(value, future)); } else { CACHE.put(key, new CacheWrapper(value, null)); } } public static <T> T get(String key, Class<T> clazz) { return clazz.cast(get(key)); } public static Object get(String key) { CacheWrapper cacheWrapper = (CacheWrapper) CACHE.get(key); return cacheWrapper == null ? null : cacheWrapper.getValue(); } public static int size() { return CACHE.size(); } public static Object remove(String key) { CacheWrapper cacheWrapper = CACHE.remove(key); if (cacheWrapper == null) return null; //清除原键值对定时器 Future future = cacheWrapper.getFuture(); if (future != null) future.cancel(true); return cacheWrapper.getValue(); } } static class CacheWrapper { private Object value; private Future future; public CacheWrapper(Object value, Future future) { this.value = value; this.future = future; } public Object getValue() { return value; } public Future getFuture() { return future; } } public static void main(String[] args) throws InterruptedException { String key = "key"; CacheManager.put(key, "testValue", 1000); System.out.println("key:" + key + ", value:" + CacheManager.get(key)); Thread.sleep(2000); System.out.println("key:" + key + ", value:" + CacheManager.get(key)); }
}


  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
  
26
  
27
  
28
  
29
  
30
  
31
  
32
  
33
  
34
  
35
  
36
  
37
  
38
  
39
  
40
  
41
  
42
  
43
  
44
  
45
  
46
  
47
  
48
  
49
  
50
  
51
  
52
  
53
  
54
  
55
  
56
  
57
  
58
  
59
  
60
  
61
  
62
  
63
  
64
  
65
  
66
  
67
  
68
  
69
  
70
  
71
  
72
  
73
  
74
  
75
  
76
  
77
  
78
  
79
  
80
  
81
  
82
  
83
  
84
  
85
  
86
  
87
  
88
  
89
  
90
  
91
  
92
  
93
  
94
  
95
  
96
  
97
  
98
  
99
  
100
  
101
  
102
  
103
  
104
  
105
  
106
  
107
  
108
  
109
  
110
  
111
  
112
  
113
  
114
  
115
  
116
  
117
  
118
  
119
  
120
  
121
  
122
  
123
  
124
  
125
  
126
  
127
  
128
  
129
  
130
 

文章来源: smilenicky.blog.csdn.net，作者：smileNicky，版权归原作者所有，如需转载，请联系作者。

原文链接：smilenicky.blog.csdn.net/article/details/108451869