一个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的并发性。