Java多线程 - 公平锁与非公平锁

synchronized内置锁是一种非公平锁，默认情况下ReentrantLock锁也是非公平锁。

1. 非公平锁

什么是非公平锁呢？

非公平锁是指多个线程获取锁的顺序并不一定是其申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁，抢锁成功的次序不一定体现为FIFO（先进先出）顺序。非公平锁的优点在于吞吐量比公平锁大，它的缺点是有可能会导致线程优先级反转或者线程饥饿现象。

使用ReentrantLock锁作为非公平锁的实战用例，具体代码如下：

public class LockTest {

    private int sum;
    
    @Test
    public void testNotFairLock() throws InterruptedException {
        // 默认是非公平锁
        ReentrantLock lock = new ReentrantLock(false);

        // 要执行的任务
        Runnable target = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"---开始抢锁");
                lock.lock();
                try{
                    System.out.println(Thread.currentThread().getName()+"---抢到了锁");
                    sum++;
                }finally {
                    lock.unlock();
                }
            }
        };

        // 创建4个线程
        Thread[] arr = new Thread[4];
        for(int i=0;i<arr.length;i++){
            arr[i] = new Thread(target,"线程"+i);
        }
        // 启动4个线程
        for(int i=0;i<arr.length;i++){
            arr[i].start();
        }
        Thread.sleep(Integer.MAX_VALUE);
    }
}

执行结果：

线程0---开始抢锁
线程2---开始抢锁
线程3---开始抢锁
线程1---开始抢锁
线程2---抢到了锁
线程3---抢到了锁
线程1---抢到了锁
线程0---抢到了锁

从输出的结果可以看出，各个线程的抢锁次序为：线程0→线程2→线程3→线程1，但是抢到锁的次序为：线程2→线程3→线程1→线程0。所以说，非公平锁是不公平的。

2. 公平锁

什么是公平锁呢？公平锁是指多个线程按照申请锁的顺序来获取锁，抢锁成功的次序体现为FIFO（先进先出）顺序。虽然ReentrantLock锁默认是非公平锁，但可以通过构造器指定该锁为公平锁，具体的代码如下：

// 默认是非公平锁,设置为true后变成公平锁
ReentrantLock lock = new ReentrantLock(true);

public class LockTest {

    private int sum;
    
    @Test
    public void testNotFairLock() throws InterruptedException {
        // 默认是非公平锁
        ReentrantLock lock = new ReentrantLock(true);

        // 要执行的任务
        Runnable target = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"---开始抢锁");
                lock.lock();
                try{
                    System.out.println(Thread.currentThread().getName()+"---抢到了锁");
                    sum++;
                }finally {
                    lock.unlock();
                }
            }
        };

        // 创建4个线程
        Thread[] arr = new Thread[4];
        for(int i=0;i<arr.length;i++){
            arr[i] = new Thread(target,"线程"+i);
        }
        // 启动4个线程
        for(int i=0;i<arr.length;i++){
            arr[i].start();
        }
        Thread.sleep(Integer.MAX_VALUE);
    }
}

执行结果：

线程1---开始抢锁
线程0---开始抢锁
线程3---开始抢锁
线程2---开始抢锁
线程1---抢到了锁
线程0---抢到了锁
线程3---抢到了锁
线程2---抢到了锁

从输出的结果可以看出，各个线程的抢锁次序为：线程1→线程0→线程3→线程2，但是抢到锁的次序为：线程1→线程0→线程3→线程2。所以说，公平锁是公平的。