1

从这个问题如何理解 ReentrantReadWriteLock 的“非公平”模式？，我认为所有线程都有相同的机会获得锁，无论哪个先来。

所以我写了这段代码来测试它：

public static void main(String[] args) {
    ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
    final ReadLock readLock = lock.readLock();
    final WriteLock writeLock = lock.writeLock();

    // hold the write lock 3s at first
    new Thread() {
        public void run() {
            writeLock.lock();
            System.out.println(Thread.currentThread().getName() + " got the write lock");
            quietSleep(3);
            writeLock.unlock();
            System.out.println(Thread.currentThread().getName() + " released the write lock");

        };
    }.start();

    // a thread want to get the read lock 1s later
    new Thread() {
        public void run() {
            quietSleep(1);
            readLock.lock();
            System.out.println(Thread.currentThread().getName() + " got the read lock");
        };
    }.start();

    // 1000 threads want to get the write lock 2s later
    for (int i = 0; i < 1000; i++) {
        new Thread() {
            public void run() {
                quietSleep(2);
                writeLock.lock();
                System.out.println(Thread.currentThread().getName() + " got the write lock");
            };
        }.start();
    }
}

private static void quietSleep(int seconds) {
    try {
        Thread.sleep(seconds * 1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

一开始，有一个线程拿到了写锁，并保持了3s。在此期间，一个线程想要获得读锁，然后有 1000 个线程想要获得写锁。

由于 ReentrantReadWriteLock 默认使用非公平模式，我认为写线程有很大的机会获得写锁。但是我运行了很多次，每次读取线程都赢了！

输出是：

Thread-0 got the write lock
Thread-0 released the write lock
Thread-1 got the read lock

我是否理解“不公平”错误？

更新 根据 paxdiablo 的回答，我将代码修改为：

new Thread() {
    public void run() {
        quietSleep(1);
        writeLock.lock();
        System.out.println(Thread.currentThread().getName() + " got the write lock");

    };
}.start();

for (int i = 0; i < 1000; i++) {
    new Thread() {
        public void run() {
            quietSleep(2);
            readLock.lock();
            System.out.println(Thread.currentThread().getName() + " got the read lock");
        };
    }.start();
}

现在有一个线程想要写锁，1000 个读线程想要读锁。但输出是：

Thread-0 got the write lock
Thread-0 released the write lock
Thread-1 got the write lock

似乎它仍然是“先到先得”。

4

1 回答 1

4

不公平只是意味着它不必以排队的方式分发锁（先到先得）。它对如何分发不做任何其他保证。事实上，如果它愿意，它仍然可以以排队的方式分发它们。

可能它更喜欢分发给读者，因为多个读者可以同时拥有锁，但如果作者获得它，所有读者和作者都会被阻止。

很久以前，我曾经不得不实现一个读/写互斥锁，它有多种模式，具体取决于您需要实现的目标：

  • 更喜欢阅读器。
  • 更喜欢作家。
  • 更喜欢备用阅读器/作者。
  • 排队访问。

听起来第一个是您的系统可能正在做的事情（我说“可能”，因为它可能是您的代码在确定性地运行，尽管具有线程性质，即每次都相同）。

如果您想了解公平和非公平之间的区别，请尝试以下操作。

  • 让一个线程获得读锁，然后休眠一分钟。
  • 在该睡眠期间，让一个线程请求写锁定以进入睡眠一分钟。
  • 然后循环十次尝试获取和释放读锁。

在公平模式下，它应该是RWRRRRRRRRRR. 那是因为除了第一个读锁之外，所有的锁都会等到获得并释放写锁（写首先进行，因为这是公平的）。

在非公平模式下，您可能会看到RRRRRRRRRRRW，读锁可能都被允许跳到写锁前面，因为它们不会干扰第一个读锁，该死的公平:-)

当然，公平的概念可能因作者而异。允许读取在写入之前潜入但有限制的算法可能在规则范围内。例如，一旦请求写锁，在排在写锁后面之前，只允许再有五个读锁偷偷通过。

我并不是说有人曾经实施过，但这肯定是一个可行的选择，在效率与公平之间取得平衡。

于 2011-11-01T04:37:39.410 回答