Question

ReentrantReadWriteLock具有公平且不公平（默认）的模式，但该文档对我来说很难理解。

我怎么能理解它？如果有一些代码示例来演示它，那就太棒了。

更新

如果我有一个写线程，并且有很多阅读线程，哪种模式更好用？如果我使用非公平模式，写作线程是否有可能获得锁定？

Answer 1

非公平意味着当准备好通过新线程获取锁时，锁不能保证谁获得锁的公平性（假设有多个线程请求锁定当时）。换句话说，可以想象一个线程可能会持续缺乏，因为其他线程总是设法任意获取锁而不是它。

公平模式更像是先来先服务，其中线程保证某种程度的公平性，以便他们以公平的方式获得锁定（例如，在开始等待的线程之前）后）。

修改

这是一个示例程序，它演示了锁的公平性（因为公平锁的写锁请求是先到先得的）。比较FAIR = true（线程始终按顺序投放）与FAIR = false（线程有时不按顺序投放）时的结果。< / p>

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class FairLocking {

    public static final boolean FAIR = true;
    private static final int NUM_THREADS = 3;

    private static volatile int expectedIndex = 0;

    public static void main(String[] args) throws InterruptedException {
        ReentrantReadWriteLock.WriteLock lock = new ReentrantReadWriteLock(FAIR).writeLock();

        // we grab the lock to start to make sure the threads don't start until we're ready
        lock.lock();

        for (int i = 0; i < NUM_THREADS; i++) {
            new Thread(new ExampleRunnable(i, lock)).start();

            // a cheap way to make sure that runnable 0 requests the first lock
            // before runnable 1
            Thread.sleep(10);
        }

        // let the threads go
        lock.unlock();
    }

    private static class ExampleRunnable implements Runnable {
        private final int index;
        private final ReentrantReadWriteLock.WriteLock writeLock;

        public ExampleRunnable(int index, ReentrantReadWriteLock.WriteLock writeLock) {
            this.index = index;
            this.writeLock = writeLock;
        }

        public void run() {
            while(true) {
                writeLock.lock();
                try {
                    // this sleep is a cheap way to make sure the previous thread loops
                    // around before another thread grabs the lock, does its work,
                    // loops around and requests the lock again ahead of it.
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    //ignored
                }
                if (index != expectedIndex) {
                    System.out.printf("Unexpected thread obtained lock! " +
                            "Expected: %d Actual: %d%n", expectedIndex, index);
                    System.exit(0);
                }

                expectedIndex = (expectedIndex+1) % NUM_THREADS;
                writeLock.unlock();
            }
        }
    }
}

编辑（再次）

关于你的更新，使用非公平锁定并不是说线程有可能获得锁定的可能性很小，而是线程必须稍等一点的可能性很小。

现在，通常随着饥饿期的增加，实际发生的那段时间的概率会降低......就像连续10次翻转硬币“头”一样，比连续9次掷硬币“头”的可能性更小次。

但是如果多个等待线程的选择算法是非随机化的，例如“具有按字母顺序排列的名称的线程总是获得锁定”那么你可能会遇到一个真正的问题，因为概率不一定会随着线程而减少变得越来越饥饿...如果一枚硬币加权到“头部”10个连续的头部基本上可能连续9个头部。

我认为，在非公平锁定的实施中，使用了某种“公平”的硬币。因此，问题确实变得公平（因此，延迟）与吞吐量相比。使用非公平锁定通常会产生更好的吞吐量，但代价是锁定请求偶尔会出现延迟峰值。哪个更适合你，取决于你自己的要求。

Answer 2

当某些线程等待锁定时，锁定必须选择一个线程才能访问关键部分：
在非公平模式下，它选择没有任何标准的线程在公平模式下，它选择等待最多时间的线程。

注意：请注意，之前解释的行为仅用于lock（）和unlock（）方法。由于tryLock（）方法在使用Lock接口时不会使线程进入休眠状态，因此fair属性不会影响其功能。

如何理解ReentrantReadWriteLock的“非公平”模式？

2 个答案:

修改

编辑（再次）