ReentrantReadWriteLock - 一次许多读者，一次一个作家？

Question

我对多线程环境有点陌生，我正在尝试针对以下情况提出最佳解决方案：

我每天早上从数据库读取一次数据，并将数据存储在 Singleton 对象的 HashMap 中。我有一个 setter 方法，仅当发生日内数据库更改时才会调用该方法（每天会发生 0-2 次）。

我还有一个 getter，它返回映射中的一个元素，并且该方法每天被调用数百次。

我担心在清空并重新创建 HashMap 时调用 getter 的情况，从而尝试在空/格式错误的列表中查找元素。如果我使这些方法同步，则​​会阻止两个读取器同时访问 getter，这可能会成为性能瓶颈。我不想对性能造成太大影响，因为写入很少发生。如果我使用 ReentrantReadWriteLock，这是否会强制任何调用 getter 的人排队，直到释放写锁？它是否允许多个读者同时访问 getter？它会一次只强制执行一名作家吗？

编码这只是一个问题吗？

private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
private final Lock read = readWriteLock.readLock();
private final Lock write = readWriteLock.writeLock();

public HashMap getter(String a) {
    read.lock();
    try {
        return myStuff_.get(a);            
    } finally {
        read.unlock();
    }
}

public void setter() 
{
    write.lock();
    try {
        myStuff_ = // my logic
     } finally {
          write.unlock();
    }
}

Answer 1

实现此目的的另一种方法（不使用锁）是写时复制模式。当您不经常写作时，它效果很好。这个想法是复制并替换字段本身。它可能如下所示：

private volatile Map<String,HashMap> myStuff_ = new HashMap<String,HashMap>();

public HashMap getter(String a) {
    return myStuff_.get(a);
}

public synchronized void setter() {
    // create a copy from the original
    Map<String,HashMap> copy = new HashMap<String,HashMap>(myStuff_);
    // populate the copy
    // replace copy with the original
    myStuff_ = copy;
}

这样，读者就完全并发了，他们付出的唯一代价是对 myStuff_ 的易失性读取（这是非常小的）。作者是同步的以确保相互排斥。

Answer 2

是的，如果写锁被一个线程持有，那么访问 getter 方法的其他线程将会阻塞，因为它们无法获取读锁。所以你在这里很好。有关更多详细信息，请阅读 ReentrantReadWriteLock 的 JavaDoc - http://download.oracle.com/javase/6/docs/api/java/util/concurrent/locks/ReentrantReadWriteLock.html

Answer 3

你每天一开始就开始做这件事……你每天更新它 0-2 次，每天阅读它 100 次。假设读取需要花费 8 小时（28800 秒）内的 1 整秒（很长的时间），您的读取负载仍然很低。查看 ReentrantReadWriteLock 的文档，您可以“调整”模式，使其“公平”，这意味着等待时间最长的线程将获得锁。因此，如果您将其设置得公平，我认为您的写入线程不会被饿死。

参考文献

ReentrantReadWriteLock