synchronized 和 ReentrantLock的区别

synchronized 和 ReentrantLock的区别

   在讨论synchronized 和 ReentrantLock的区别前，我们先了解一下什么是公平锁和非公平锁

   一、 公平锁和非公平锁

   从公平的角度来说，Java 中的锁总共可分为两类：公平锁和非公平锁。但公平锁和非公平锁有哪些区别？孰优孰劣呢？在 Java 中的应用场景又有哪些呢？接下来我们一起来看。

   1.  定义

   公平锁：每个线程获取锁的顺序是按照线程访问锁的先后顺序获取的，最前面的线程总是最先获取到锁。

   非公平锁：每个线程获取锁的顺序是随机的，并不会遵循先来先得的规则，所有线程会竞争获取锁。

   2. 代码演示

   接下来我们使用 ReentrantLock 来演示一下公平锁和非公平锁的执行差异，首先定义一个公平锁，开启 3 个线程，每个线程执行两次加锁和释放锁并打印线程名的操作，如下代码所示：

   非公平锁：

public class ReentrantLockFairTest {
    static Lock lock = new ReentrantLock();
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                for (int j = 0; j < 2; j++) {
                    lock.lock();
                    try {
                        System.out.println("当前线程：" + Thread.currentThread().getName());
                    } finally {
                        lock.unlock();
                    }
                }
            }).start();
        }
    }
}

//执行结果
当前线程：Thread-0
当前线程：Thread-0
当前线程：Thread-1
当前线程：Thread-1
当前线程：Thread-2
当前线程：Thread-2

   公平锁：

public class ReentrantLockUnfairTest {
    static Lock lock = new ReentrantLock(true);
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                for (int j = 0; j < 2; j++) {
                    lock.lock();
                    try {
                        System.out.println("当前线程：" + Thread.currentThread().getName());
                    } finally {
                        lock.unlock();
                    }
                }
            }).start();
        }
    }
}

//执行结果
当前线程：Thread-0
当前线程：Thread-1
当前线程：Thread-2
当前线程：Thread-0
当前线程：Thread-1
当前线程：Thread-2

    说明：

     从上述结果可以看出，使用公平锁线程获取锁的顺序是：A -> B -> C -> A -> B -> C，也就是按顺序获取锁。而非公平锁，获取锁的顺序是 A -> A -> B -> B -> C -> C，原因是所有线程都争抢锁时，因为当前执行线程处于活跃状态，其他线程属于等待状态（还需要被唤醒），所以当前线程总是会先获取到锁，所以最终获取锁的顺序是：A -> A -> B -> B -> C -> C。

    3. 执行流程分析

    1）公平锁执行流程

    获取锁时，先将线程自己添加到等待队列的队尾并休眠，当某线程用完锁之后，会去唤醒等待队列中队首的线程尝试去获取锁，锁的使用顺序也就是队列中的先后顺序，在整个过程中，线程会从运行状态切换到休眠状态，再从休眠状态恢复成运行状态，但线程每次休眠和恢复都需要从用户态转换成内核态，而这个状态的转换是比较慢的，所以公平锁的执行速度会比较慢。

    2）非公平锁执行流程

   当线程获取锁时，会先通过 CAS 尝试获取锁，如果获取成功就直接拥有锁，如果获取锁失败才会进入等待队列，等待下次尝试获取锁。这样做的好处是，获取锁不用遵循先到先得的规则，从而避免了线程休眠和恢复的操作，这样就加速了程序的执行效率。

    

    公平锁和非公平锁的性能测试结果如下，以下测试数据来自于《Java并发编程实战》：

    说明：从上述结果可以看出，使用非公平锁的吞吐率（单位时间内成功获取锁的平均速率）要比公平锁高很多。 

    4. 公平锁和非公平锁有何区别

    公平性是指在竞争场景中，当公平性为真时，会倾向于将锁赋予等待时间最久的线程。公平性是减少线程“饥饿”（个别线程长期等待锁，但始终无法获取）情况发生的一个办法。

   1）公平锁能保证：老的线程排队使用锁，新线程仍然排队使用锁。

   2）非公平锁保证：老的线程排队使用锁；但是无法保证新线程抢占已经在排队的线程的锁。

   结论：公平锁指的是哪个线程先运行，那就可以先得到锁。非公平锁是不管线程是否是先运行，新的线程都有可能抢占已经在排队的线程的锁。

   5.  优缺点分析

   公平锁的优点是按序平均分配锁资源，不会出现线程饿死的情况，它的缺点是按序唤醒线程的开销大，执行性能不高。

   非公平锁的优点是执行效率高，谁先获取到锁，锁就属于谁，不会“按资排辈”以及顺序唤醒，但缺点是资源分配随机性强，可能会出现线程饿死的情况。

   二、synchronized（内置锁）

   对于synchronized来说，它是java语言的关键字，是原生语法层面的互斥，需要jvm实现。

   以下面代码为例：

public class SynchronizedTest {
    public static void main(String[] args) {
        synchronized (SynchronizedTest.class) {
            System.out.println("Java");
        }
    }
}

   查看编译后生成的字节码：

   可以看出 JVM（Java 虚拟机）是采用 monitorenter 和 monitorexit 两个指令来实现同步的，monitorenter 指令相当于加锁，monitorexit 相当于释放锁。而 monitorenter 和 monitorexit 就是基于 Monitor 实现的。synchronized 本质是通过进入和退出的 Monitor 对象来实现线程安全的。

   三、ReentrantLock （可重入锁）

   ReentrantLock（可重入锁）是 Java 5 开始提供的锁实现，它的功能和 synchronized 基本相同。相比于synchronized，ReentrantLock在功能上更加丰富，它具有可重入、可中断、可限时、公平锁等特点。

   在jdk1.5里面，ReentrantLock的性能是明显优于synchronized的，但是在jdk1.6里面，synchronized做了优化，他们之间的性能差别已经不明显了。

   如下图：

    

   1.  非阻塞地获取锁

   当前线程尝试获取锁，如果这一时刻锁没有被其他线程获取到，则成功获取并持有锁。使用tryLock()方法。

    tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。

    尝试获取锁 tryLock（），代码示例如下：   

public class Test{
    public static Lock lock = new ReentrantLock();
 
    public String test() throws Exception {
        if(lock.tryLock()){//尝试获取锁
            try {
                //TODO
            } catch (Exception e) {
                throw new Exception(e);
            } finally {
                lock.unlock();
            }
        }else{
        //不能获取锁
        }
        return null;
    }
}

   2. 可限时获取锁

   在指定的时间范围内获取锁；如果截止时间到了仍然无法获取锁，则返回。

   tryLock() 有一个扩展方法 tryLock(long timeout, TimeUnit unit) 用于尝试一段时间内获取锁，具体实现代码如下：

public class TryLockTest2 {
    static Lock reentrantLock = new ReentrantLock();

    public static void main(String[] args) {
        // 线程一
        new Thread(() -> {
            reentrantLock.lock();
            try {
                System.out.println(LocalDateTime.now());
                Thread.sleep(2 * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                reentrantLock.unlock();
            }
        }).start();
        // 线程二
        new Thread(() -> {
            try {
                Thread.sleep(1 * 1000);
                System.out.println(reentrantLock.tryLock(3, TimeUnit.SECONDS));
                System.out.println(LocalDateTime.now());
            } catch ( InterruptedException e ){25                 e.printStackTrace();
            }
        }).start();
    }
}

   说明：tryLock(long time, TimeUnit unit) 方法和 tryLock() 方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。

   比如：tryLock(3, TimeUnit.SECONDS) 表示获取锁的最大等待时间为 3 秒，期间会一直尝试获取，而不是等待 3 秒之后再去获取锁。

   3. 可中断锁

   该方式会尝试获取锁，并且是阻塞的，但当未获取到锁时，如果当前线程被设置了中断状态，则会抛出。使用lockInterruptibly()方法。

   代码示例如下:

public class DeadLockWithReentrantLock implements Runnable{
    private boolean flag;
    //锁1
    private static ReentrantLock lock1 = new ReentrantLock();
    //锁2
    private static ReentrantLock lock2 = new ReentrantLock();

    public DeadLockWithReentrantLock(boolean flag) {
        this.flag = flag;
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new DeadLockWithReentrantLock(true));
        t1.setName("A");
        Thread t2 = new Thread(new DeadLockWithReentrantLock(false));
        t2.setName("B");
        t1.start();
        t2.start();
        TimeUnit.SECONDS.sleep(5);
        System.out.println("线程B设置中断标记，线程B将退出死锁状态");
        t2.interrupt();

    }

    @Override
    public void run() {
        try {
            if (flag) {
                //获取锁
                lock1.lockInterruptibly();
                System.out.println("线程 ： " + Thread.currentThread().getName() + " get lock1");
                TimeUnit.SECONDS.sleep(2);
                System.out.println("线程 ： " + Thread.currentThread().getName() + " try to get lock2");
                lock2.lockInterruptibly();
            } else {
                lock2.lockInterruptibly();
                System.out.println("线程 ： " + Thread.currentThread().getName() + " get lock2");
                TimeUnit.SECONDS.sleep(2);
                System.out.println("线程 ： " + Thread.currentThread().getName() + " try to get lock1");
                lock1.lockInterruptibly();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //如果当前线程持有锁1,释放锁1
            if (lock1.isHeldByCurrentThread()) {
                lock1.unlock();
            }
            //如果当前线程持有锁2,释放锁2
            if (lock2.isHeldByCurrentThread()) {
                lock2.unlock();
            }
            System.out.println("线程 ： " + Thread.currentThread().getName() + " 退出");
        }
    }
}

   执行结果：

    

   PS：使用 thread.interrupt() 方法可以中断线程执行。

   注意：当一个线程获取了锁之后，是不会被interrupt()方法中断的。因为单独调用interrupt()方法不能中断正在运行过程中的线程，只能中断阻塞过程中的线程。因此当通过lockInterruptibly()方法获取某个锁时，如果不能获取到，只有进行等待的情况下，是可以响应中断的。

   4.  使用注意事项

   在使用ReentrantLock类的时，一定要注意三点：

   1）在使用 ReentrantLock 时要特别小心，unlock 释放锁的操作一定要放在 finally 中，否者有可能会出现锁一直被占用，从而导致其他线程一直阻塞的问题。

   2) 不要将获取锁的过程写在try块内，因为如果在获取锁时发生了异常，异常抛出的同时，也会导致锁无故被释放。

   3）如果lock方法在try代码块之内，可能由于其它方法抛出异常，导致在finally代码块中，unlock对未加锁的对象解锁，它会调用AQS的tryRelease方法（取决于具体实现类），抛出IllegalMonitorStateException异常。

   3) ReentrantLock提供了一个newCondition的方法，以便用户在同一锁的情况下可以根据不同的情况执行等待或唤醒的动作。 

   四、synchronized 和 ReentrantLock的区别

   ReentrantLock是Lock的实现类，是一个互斥的同步器，在多线程高竞争条件下，ReentrantLock比synchronized有更加优异的性能表现。

   1. 锁类型不同

   在 Java 语言中，锁 synchronized 和 ReentrantLock 默认都是非公平锁，当然我们在创建 ReentrantLock 时，可以手动指定其为公平锁，但 synchronized 只能为非公平锁。  

   new ReentrantLock() 默认创建的为非公平锁，如果要创建公平锁可以使用 new ReentrantLock(true)。

   2. 获取锁和释放锁的方式不同

   ReentrantLock 必须手动获取与释放锁，而 synchronized 不需要手动释放和开启锁；

   ReentrantLock示例如下图：

    

     synchronized 会自动加锁和释放锁，当进入 synchronized 修饰的代码块之后会自动加锁，当离开 synchronized 的代码段之后会自动释放锁，

     synchronized示例如下图：

   

   3. 用法比较

   ReentrantLock 只适用于代码块锁，而 synchronized 使用场景更广，可以修饰普通方法、静态方法和代码块等   

   4. 响应中断不同

   ReentrantLock 可以响应中断，解决死锁的问题，而 synchronized 不能响应中断。

   ReentrantLock 可以使用 lockInterruptibly 获取锁并响应中断指令，而 synchronized 不能响应中断，也就是如果发生了死锁，使用 synchronized 会一直等待下去，也就是说这种无限等待获取锁的行为无法被中断。而使用 ReentrantLock 可以响应中断并释放锁，从而解决死锁的问题。

   5. 底层实现

   synchronized 是 JVM 层面通过监视器（Monitor）实现的，而 ReentrantLock 是通过 CAS+AQS（AbstractQueuedSynchronizer）程序级别的 API 实现。

   五、补充知识点：AQS

   AbstractQueuedSynchronizer，是一个用于构建锁和同步容器的框架。

   事实上concurrent包内许多类都是基于AQS构建，例如ReentrantLock，Semaphore，CountDownLatch，ReentrantReadWriteLock，FutureTask等。AQS解决了在实现同步容器时设计的大量细节问题。

   AQS使用一个FIFO的队列表示排队等待锁的线程，队列头节点称作“哨兵节点”或者“哑节点”，它不与任何线程关联。其他的节点与等待线程关联，每个节点维护一个等待状态waitStatus。 

   六、总结
   在 Java 语言中，锁的默认实现都是非公平锁，原因是非公平锁的效率更高，使用 ReentrantLock 可以手动指定其为公平锁。非公平锁注重的是性能，而公平锁注重的是锁资源的平均分配，所以我们要选择合适的场景来应用二者。

   ReentrantLock 使用更加灵活，效率也高，不过 ReentrantLock 只能修饰代码块，使用 ReentrantLock 需要开发者手动释放锁，如果忘记释放则该锁会一直被占用。synchronized 使用场景更广，可以修饰普通方法、静态方法和代码块等。

 

  参考链接：

  https://www.cnblogs.com/vipstone/p/16248006.html

  https://juejin.cn/post/6844903695298068487