Lock的公平锁与非公平锁

Lock是用于控制多线程访问共享资源的同步机制，Lock接口提供了对锁的操作，包括公平锁与非公平锁。

ReentrantLock（可重入锁）是Lock的一个实现类，它提供了可重入的互斥锁。

ReentrantLock 可以通过构造函数中传入参数来指定锁的实现类型，默认是非公平锁。

以下是 ReentrantLock 创建公平锁和非公平锁示例代码：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class FairNonfairLock {

    // 公平锁
    private static Lock fairLock = new ReentrantLock(true);
    // 非公平锁
    private static Lock unFairLock = new ReentrantLock(false);

    public static void main(String[] args) {
        // 公平锁
        Thread fairThread1 = new Thread(new Task(fairLock),"fairThread1");
        Thread fairThread2 = new Thread(new Task(fairLock),"fairThread2");

        // 非公平锁
        Thread unFairThread1 = new Thread(new Task(unFairLock),"unFairThread1");
        Thread unFairThread2 = new Thread(new Task(unFairLock),"unFairThread2");

        // 启动线程
        fairThread1.start();
        fairThread2.start();

        unFairThread1.start();
        unFairThread2.start();
    }

    static class Task implements Runnable {

        private Lock lock;

        public Task(Lock lock) {
            this.lock = lock;
        }

        @Override
        public void run() {
            // 请求锁
            System.out.println(Thread.currentThread().getName() + " is trying to acquire the lock.");
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + " has acquired the lock.");
                // 执行需要同步的代码块
            } finally {
                lock.unlock();
                // 释放锁
                System.out.println(Thread.currentThread().getName() + " has released the lock.");
            }
        }

    }
}

上述代码，运行结果如下图： 

在上述示例中，我们创建了两个使用公平锁的线程（fairThread1和fairThread2），以及两个使用非公平锁的线程（unFairThread1和unFairThread2）。每个线程都尝试获取锁资源，并在获取到锁后执行同步的代码块，最后释放锁资源。

可以观察到，公平锁的线程按照先到先得的原则获取锁资源，而非公平锁的线程可能会插队获取锁资源。