java中的同步——新的ReentrantLock（true）和新的ReentrantLock（false）产生相同的结果？

ReentrantLock在创建锁对象时提供

boolean fair

标志

公平

：

真实

线程可以根据等待的时间访问关键部分

公平

：

错误

没有为线程提供关键部分的特定策略

下面是我的代码：

public class ThreadDemo {
    private Lock lock = new ReentrantLock(false);

    public static void main(String[] args) {
        ThreadDemo td = new ThreadDemo();
        Thread[] tArr = new Thread[5];
        // Creates 5 thread and stores them in a array
        for (int i = 0; i < 5; i++) {
            tArr[i] = new Thread(() -> {
                td.enterCriticalSection(new Date().getTime());
            }, "Thread " + i);
        }
        // Iterate through the array and start it.
        for (int i = 0; i < 5; i++) {
            tArr[i].start();
            try {
                Thread.currentThread().sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }
    }

    public void enterCriticalSection(long waitTime) {
        System.out.println(Thread.currentThread().getName() + " requesting critical section at:"
                + new SimpleDateFormat("HH:mm:ss:SSS").format(new Date().getTime()));
        // Gets Lock
        lock.lock();

        try {
            /*
             * Logs the entry time in critical section and waiting period for
             * the thread
             */
            System.out.println(Thread.currentThread().getName() + " in critical section at  "
                    + new SimpleDateFormat("HH:mm:ss:SSS").format(new Date().getTime()));
            Thread.currentThread().sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            // Releases lock
            lock.unlock();
        }
            
        }
}

---

所有的

fair-false

意味着锁将允许线程以它想要的方式进入。对于少量的线程，这可能恰好是它们一直在等待的顺序，但它不能保证这一点。

All

fair-false

意味着锁会让线程按照它想要的方式进入。对于少量线程，这可能恰好是他们一直在等待的顺序，但这并不能保证这一点。

我最初尝试了10-20个线程，并尝试了多次，甚至我也认为它会根据关键请求的顺序分配锁section@DharmvirTiwarijavadoc说，

ReentrantLock（true）

必须创建一个公平的锁，但它并没有说

ReentrantLock（false）

必须创建一个不公平的锁。如果您的JRE即使在

fair==false

时也似乎创建了一个公平锁，那么这并不能证明它有任何问题。我最初尝试了10-20个线程，并尝试了多次，甚至我也认为它会根据关键请求的顺序分配锁section@DharmvirTiwarijavadoc说，

ReentrantLock（true）

必须创建一个公平的锁，但它并没有说

ReentrantLock（false）

必须创建一个不公平的锁。如果您的JRE似乎在

fair==false

时创建了一个公平锁，那么这并不能证明它有任何问题。

Thread 0 requesting critical section at:01:57:48:562
Thread 0 in critical section at  01:57:48:563
Thread 1 requesting critical section at:01:57:49:520
Thread 2 requesting critical section at:01:57:50:520
Thread 3 requesting critical section at:01:57:51:520
Thread 4 requesting critical section at:01:57:52:520
Thread 1 in critical section at  01:57:53:564
Thread 2 in critical section at  01:57:58:564
Thread 3 in critical section at  01:58:03:565
Thread 4 in critical section at  01:58:08:566