可重入读写锁 - 多个读者同时，一个写者一次？

Question

可重入读写锁 - 多个读者同时，一个写者一次？

javamultithreadingsynchronizedreentrantreadwritelock

12

我对多线程环境有些陌生，正在尝试为以下情况找到最佳解决方案：

我每天早上从数据库中读取数据，并将数据存储在 Singleton 对象的 HashMap 中。当 intra-day 数据库更改发生时（每天可能会发生0-2次），只有调用 setter 方法。

还有一个 getter 方法，用于返回 map 中的元素，这个方法每天会被调用数百次。

我担心 getter 在我清空和重新创建 HashMap 时被调用，从而尝试在一个空/畸形列表中查找元素。如果我使这些方法同步化，它将阻止两个 reader 同时访问 getter，这可能会成为性能瓶颈。因为写入非常不频繁，所以我不想付出太大的性能损失。如果我使用 ReentrantReadWriteLock，它会强制要求任何调用 getter 的人排队等待写锁释放吗？它是否允许多个 reader 同时访问 getter？它是否强制只有一个 writer 可以同时写入？

编写这个代码只是...

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();
    }
}

- Sarah

3个回答

2

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

- kuriouscoder

0

你在一天开始的时候就开始了这个事情... 你每天会更新0-2次，而且每天要读它上百次。假设每次阅读需要1秒钟（非常长的时间），在8小时的工作日里（28800秒），你的读取负载仍然非常低。通过查看ReentrantReadWriteLock的文档，你可以“调整”模式，使其变得“公平”，这意味着等待时间最长的线程将获得锁。所以如果你将其设置为公平，我认为你的写入线程不会被饿死。

参考资料

ReentrantReadWriteLock

- Andrew

我所包含的代码是否实现了我所描述的多个读取器方案？我只想防止读取器在写入器正在进行时进行读取。每天有数百次读取，但在任何时候，它们可能会成批地出现并对我的getter发起20-30个调用。 - Sarah

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- sjlee · Accepted Answer

另一种实现这个目的的方法（不使用锁）是使用“写时复制”模式。它在你不经常进行写操作时效果很好。其思想是复制并替换字段本身。代码可能如下所示：

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_进行了一个易变读取（这很少）。写者被同步以确保互斥。