java并发编程-读写锁

最近项目中需要用到读写锁

读写锁适用于读操作多，写操作少的场景，假设你的程序中涉及到对一些共享资源的读和写操作，且写操作没有读操作那么频繁。在没有写操作的时候，两个线程同时读一个资源没有任何问题，所以应该允许多个线程能在同时读取共享资源。但是如果有一个线程想去写这些共享资源，就不应该再有其它线程对该资源进行读或写，也就是说 读-读能共存，读-写不能共存，写-写不能共存

我们直接使用java的读写锁  ReadWriteLock

如下代码是使用缓存的典型场景：

public class ReadWriteLockTest {

    private static ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    private static LoadingCache<Long, LinkModel> windowCache = CacheBuilder
            .newBuilder()
            .expireAfterWrite(Config.ALL_RELOAD_CYCLE+,TimeUnit.HOURS) //写入ALL_RELOAD_CYCLE小时后remove掉
            .build(new CacheLoader<Long, LinkModel>() {
                @Override
                public LinkModel load(Long key) throws Exception {
                    return LinkModelDAO.getLinkModelWindow(key);
                }
            });

    public static LinkModel getLinkModelWindow(long linkId) {
        try {
            readWriteLock.readLock().lock();
            LinkModel model = windowCache.get(linkId);
            return model;
        } catch (ExecutionException e) {
            LOGGER.error(e.getMessage(), e);
        }finally {
            readWriteLock.readLock().unlock();
        }
        return null;
    }

    public static  void refershModelWindowCache(String partitionId){

        try {
            readWriteLock.writeLock().lock();
            HashMap<Long, LinkModel> linkModelHashMap = LinkModelDAO.getLinkModelWindowsByPartition(partitionId,Config.ALL_ROADCLASS_LIST);
            if(MapUtils.isNotEmpty(linkModelHashMap)){
                windowCache.cleanUp();
                windowCache.putAll(linkModelHashMap);
            }
        } catch (EventMiningException e) {
            LOGGER.error(e.getMessage(), e);
        }finally {
            readWriteLock.writeLock().unlock();
        }

    }
}

下面这篇文章写得比较详细：

http://ifeve.com/read-write-locks/