Java非公平可重入WriteLock究竟是如何工作的？

Question

我写了下面的测试代码在Java使用ReentantReadWriteLock来了解公平和不公平模式之间的区别。然而，我看到在两种模式下，结果和输出总是相同的。它似乎总是在公平模式下工作。谁能解释一下，在何种情况下，公平和不公平模式会导致不同的行为？

package lockTest;

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class MyLockTest {
    static private ReadWriteLock myLock = new ReentrantReadWriteLock(false);

    public class Reader extends Thread {
        int val_;
        public Reader(int val) {
            val_ = val;
        }
        public void run() {
            if (val_ > 0) {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }

            myLock.readLock().lock();
            System.out.println(Thread.currentThread().getName() + ": Reader inside critical section - val: " + val_ + "-----");
            try {
                Thread.sleep(6000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            myLock.readLock().unlock();
        }
    }

    public class Writer extends Thread {
        public void run() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            myLock.writeLock().lock();
            System.out.println(Thread.currentThread().getName() + ": Writer inside critical section *****");
            try {
                Thread.sleep(6000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            myLock.writeLock().unlock();
        }
    }

    public static void main(String[] args) {
        MyLockTest test1 = new MyLockTest();
        MyLockTest.Reader reader1 = test1.new Reader(0);
        MyLockTest.Writer writer1 = test1.new Writer();
        MyLockTest.Reader reader2 = test1.new Reader(1);

        reader2.start();
        writer1.start();
        reader1.start();
    }
}

输出总是：

Thread-0: Reader inside critical section - val: 0-----
Thread-1: Writer inside critical section *****
Thread-2: Reader inside critical section - val: 1-----

当我将锁创建更改为公平模式时，上面的输出是我期望看到的：

static private ReadWriteLock myLock = new ReentrantReadWriteLock(true);

对于非公平模式，我希望看到以下输出：

Thread-0: Reader inside critical section - val: 0-----
Thread-2: Reader inside critical section - val: 1-----
Thread-1: Writer inside critical section *****

Answer 1

使用“公平”与“非公平”模式会影响在争用情况下如何将锁分配给线程。

从Javadoc for ReentantReadWriteLock：使用非公平模式，未指定进入读写锁的顺序，而使用公平模式，线程使用近似到达顺序策略争夺条目。

我们可以看到使用公平/非公平是如何通过让一些线程争用同一个锁来影响程序执行的；请参阅下面的程序。

运行示例代码时，不同的线程会争用一个ReentrantWriteLock；在1000次锁操作之后，我们转储每个线程获得锁的次数。

如果使用USE\u FAIR=false，计数是随机的，可能的输出是：

Thread thread-B finished, count=920
Thread thread-A finished, count=79
Thread thread-D finished, count=0
Thread thread-C finished, count=0

在使用USE_FAIR=true的情况下，输出总是像

Thread thread-D finished, count=249
Thread thread-A finished, count=250
Thread thread-C finished, count=250
Thread thread-B finished, count=250

示例代码

package sample1;

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class UseLock {

  public static void main(String[] args) {
    UseLock o = new UseLock();
    o.go();
  }

  private void go() {
    TotalPermits tp = new TotalPermits();

    tp.lock.writeLock().lock();

    Contender a = new Contender(tp, "thread-A");
    Contender b = new Contender(tp, "thread-B");
    Contender c = new Contender(tp, "thread-C");
    Contender d = new Contender(tp, "thread-D");

    a.start();
    b.start();
    c.start();
    d.start();

    tp.lock.writeLock().unlock();
  }
}

class TotalPermits {
  private static final boolean USE_FAIR = true;

  private int count = 1_000;
  ReentrantReadWriteLock lock = new ReentrantReadWriteLock(USE_FAIR);

  public boolean get() {
    try {
      lock.writeLock().lock();
      try {
        Thread.sleep(1);
      } catch (InterruptedException e) { }
      return --count>0;
    } finally {
      lock.writeLock().unlock();
    }
  }
}

class Contender extends Thread {
  private int count = 0;
  final String name;
  final TotalPermits tp;

  Contender(TotalPermits tp, String name) {
    this.tp = tp;
    this.name = name;
  }

  @Override
  public void run() {
    while ( tp.get() ) {
      count++;
    }
    System.out.printf("Thread %s finished, count=%d%n", name, count);
  }
}

注:

上面的示例代码使用了一个“写”锁，一次只能由一个线程持有。所以我们可以用它来在竞争者之间划分N个许可证。另一方面，"读"锁可以由多个线程持有，只要没有一个线程持有写锁。