一个cache的改造过程
在分布式的程序中，cache的合理使用可以带来性能上的极大提升，尤其是在 资源创建需要昂贵的开销 时。cache的设计最重要的是要保证 线程安全和高效性 。下面以代码为例，介绍了三种cache的写法。
1. 粗放的加锁
以下是代码片段：
public class Cache1 {
private HashMap<String, ServerGroup> route2SG = null;
public Cache1() {
route2SG = new HashMap<String, ServerGroup>();
}
public synchronized ServerGroup get(String routeKey) throws IOException {
ServerGroup sg = null;
sg = route2SG.get(routeKey);
if (sg == null) {
sg = getServerGroup(routeKey);
route2SG.put(routeKey, sg);
}
return sg;
}
public synchronized void remove(String routeKey) {
route2SG.remove(routeKey);
}
private ServerGroup getServerGroup(String routeKey) throws IOException {
ServerGroup sg = null;
/**
* Construct ServerGroup here
*/
return sg;
}
}
2. 读写锁
以下是代码片段：
public class Cache2 {
private ConcurrentHashMap<String, ServerGroup> route2SG = null;
private final ReadWriteLock lock = new ReentrantReadWriteLock();
public Cache2() {
route2SG = new ConcurrentHashMap<String, ServerGroup>();
}
public ServerGroup get(String routeKey) throws IOException {
ServerGroup sg = null;
try {
lock.readLock().lock();
sg = route2SG.get(routeKey);
if (sg == null) {
lock.readLock().unlock();
lock.writeLock().lock();
sg = route2SG.get(routeKey);
if (sg == null) {
sg = getServerGroup(routeKey);
route2SG.put(routeKey, sg);
}
lock.readLock().lock();
lock.writeLock().unlock();
}
} catch (IOException e) {
lock.writeLock().unlock();
throw (e);
}
lock.readLock().unlock();
return sg;
}
public void remove(String routeKey) {
try {
lock.writeLock().lock();
route2SG.remove(routeKey);
} finally {
lock.writeLock().unlock();
}
}
private ServerGroup getServerGroup(String routeKey) throws IOException {
ServerGroup sg = null;
/**
* Construct ServerGroup here
*/
return sg;
}
}
3. 无锁
以下是代码片段：
public class Cache3 {
private ConcurrentHashMap<String, FutureTask<ServerGroup>> route2SGFT = null;
public Cache3() {
route2SGFT = new ConcurrentHashMap<String, FutureTask<ServerGroup>>();
}
public ServerGroup get(String routeKey) throws IOException, InterruptedException, ExecutionException {
FutureTask<ServerGroup> ft = route2SGFT.get(routeKey);
if (ft != null) {
return ft.get();
}
FutureTask<ServerGroup> sft = new FutureTask<ServerGroup>(new ConstructSGTask(routeKey));
FutureTask<ServerGroup> old = route2SGFT.putIfAbsent(routeKey, sft);
if (old == null) {
sft.run();
}
return sft.get();
}
public void remove(String routeKey) {
route2SGFT.remove(routeKey);
}
class ConstructSGTask implements Callable<ServerGroup> {
private final String key;
public ConstructSGTask(String key) {
super();
this.key = key;
}
@Override
public ServerGroup call() throws Exception {
return getServerGroup(key);
}
}
private ServerGroup getServerGroup(String routeKey) throws IOException {
ServerGroup sg = null;
/**
* Construct ServerGroup here
*/
return sg;
}
}
总结，
从三份代码中可以看出，锁的粒度从粗放到无，这个就极大的提高了cache的并发性。
正文到此结束
热门推荐
相关文章
近期评论
-
666
-
文章和留言都翻到11页了 没有OOM
-
-
朋友，翻页到11页，及以后，会出现OOM，无法访问
-
-
-
-
版本号是多少，你可以下载哪个代码仓库，jdk选1.8 直接跑就行
-
-
Loading...
![[HBLOG]公众号](https://www.liuhaihua.cn/img/qrcode_gzh.jpg)
