cache的改造过程

一个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) { old=sft; old.run(); } return old.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的并发性。