锁定或等待缓存加载

Question

我们需要锁定一个负责将数据库日期加载到基于 HashMap 的缓存中的方法。

可能的情况是第二个线程尝试访问该方法，而第一个方法仍在加载缓存。

在这种情况下，我们认为第二个线程的努力是多余的。因此，我们希望第二个线程等到第一个线程完成，然后返回（无需再次加载缓存）。

我有什么作品，但似乎很不雅。有没有更好的解决方案？

private static final ReentrantLock cacheLock = new ReentrantLock();
private void loadCachemap() {
    if (cacheLock.tryLock()) {
        try {
            this.cachemap = retrieveParamCacheMap();
        } finally {
            cacheLock.unlock();
        }
    } else {
        try {           
            cacheLock.lock(); // wait until thread doing the load is finished
        } finally {
            try {
                cacheLock.unlock();
            } catch (IllegalMonitorStateException e) {
                logger.error("loadCachemap() finally {}",e);
            }
        }
    }
}

Answer 1

我更喜欢使用读锁和写锁的更具弹性的方法。比如：

private static final ReadWriteLock cacheLock = new ReentrantReadWriteLock();
private static final Lock cacheReadLock = cacheLock.readLock();
private static final Lock cacheWriteLock = cacheLock.writeLock();

private void loadCache() throws Exception {
    // Expiry.
    while (storeCache.expired(CachePill)) {
        /**
         * Allow only one in - all others will wait for 5 seconds before checking again.
         *
         * Eventually the one that got in will finish loading, refresh the Cache pill and let all the waiting ones out.
         *
         * Also waits until all read locks have been released - not sure if that might cause problems under busy conditions.
         */
        if (cacheWriteLock.tryLock(5, TimeUnit.SECONDS)) {
            try {
                // Got a lock! Start the rebuild if still out of date.
                if (storeCache.expired(CachePill)) {
                    rebuildCache();
                }
            } finally {
                cacheWriteLock.unlock();
            }
        }
    }
}

请注意，storeCache.expired(CachePill) 检测到一个陈旧的缓存可能比您想要的更多，但这里的概念是相同的，在更新缓存之前建立一个写锁，这将拒绝所有读取尝试，直到重建完成。此外，在某种循环中管理多次写入尝试，或者只是退出并让读锁等待访问。

从缓存中读取现在看起来像这样：

public Object load(String id) throws Exception {
    Store store = null;
    // Make sure cache is fresh.
    loadCache();
    try {
        // Establish a read lock so we do not attempt a read while teh cache is being updated.
        cacheReadLock.lock();
        store = storeCache.get(storeId);
    } finally {
        // Make sure the lock is cleared.
        cacheReadLock.unlock();
    }
    return store;
}

这种形式的主要好处是读取访问不会阻止其他读取访问，但在重建期间一切都会干净地停止 - 甚至是其他重建。

Answer 2

你没有说你的结构有多复杂，你需要多少并发/拥塞。有很多方法可以满足您的需求。

如果您的数据很简单，请使用 ConcurrentHashMap 或类似方法来保存您的数据。然后不管在线程中读写。

另一种选择是使用actor模型并将读/写放在同一个队列中。

Answer 3

如果您只需要填写一个在请求后从数据库初始化的只读映射，您可以使用任何形式的双重检查锁定，它可以通过多种方式实现。最简单的变体如下：

  private volatile Map<T, V> cacheMap;

  public void loadCacheMap() {
      if (cacheMap == null) {
          synchronized (this) {
              if (cacheMap == null) {
                  cacheMap = retrieveParamCacheMap();
              }
          }
      }
  }

但我个人更愿意在这里避免任何形式的同步，并确保在任何其他线程可以访问它之前完成初始化（例如以 DI 容器中的 init 方法的形式）。在这种情况下，您甚至可以避免 volatile 的开销。

编辑：答案仅在预期初始加载时有效。在多次更新的情况下，您可以尝试用其他形式的测试和测试和设置来替换 tryLock，例如使用这样的东西：

  private final AtomicReference<CountDownLatch> sync = 
    new AtomicReference<>(new CountDownLatch(0));

  private void loadCacheMap() {
      CountDownLatch oldSync = sync.get();
      if (oldSync.getCount() == 0) { // if nobody updating now
          CountDownLatch newSync = new CountDownLatch(1);
          if (sync.compareAndSet(oldSync, newSync)) {
              cacheMap = retrieveParamCacheMap();
              newSync.countDown();
              return;
          }
      }
      sync.get().await();
  }