JUC面试（十一）—

可重入锁

可重入锁又名递归锁

是指在同一个线程在外层方法获取锁的时候，再进入该线程的内层方法会自动获取锁(前提，锁对象得是同一个对象)，不会因为之前已经获取过的锁还没释放而阻塞。

Java中ReentrantLock和synchronized都是可重入锁，可重入锁的一个优点是可一定程度避免死锁。

自己可以获取自己的内部锁，其实都是同一把锁

隐式锁synchronized验证

同步块：

/**
 * 可重入锁：可重复可递归调用的锁，在外层使用锁之后，在内层仍然
 * 可以使用，并且不发生死锁，这样的锁就叫做可重入锁
 *
 * 在一个Synchronized修饰的方法或代码块的内部
 * 调用本类的其他Synchronized修饰的方法或代码块时，是永远可以得到锁的
 */
public class ReEnterLockDemo {

    static Object objectLockA = new Object();

    public static void m1(){
        new Thread(() -> {
            synchronized ((objectLockA)){
                System.out.println(Thread.currentThread().getName() + "\t" + "外层锁");
                synchronized ((objectLockA)){
                    System.out.println(Thread.currentThread().getName() + "\t" + "中层锁");
                    synchronized ((objectLockA)){
                        System.out.println(Thread.currentThread().getName() + "\t" + "内层锁");
                    }
                }
            }
        }, "thread1").start();
    }

    public static void main(String[] args) {
        m1();
    }
}

thread1	外层锁
thread1	中层锁
thread1	内层锁

同步方法：

//锁的是类实例
    //synchronized修饰的方法或者代码块的内部
    //调用本类的其他synchronized修饰的方法或者代码块时，是可以得到锁的，都是同一把锁
    public synchronized void method1(){
        System.out.println(Thread.currentThread().getName() + "\t" + "外层锁");
        method2();
    }

    public synchronized void method2(){
        System.out.println(Thread.currentThread().getName() + "\t" + "中层锁");
        method3();
    }

    public synchronized void method3(){
        System.out.println(Thread.currentThread().getName() + "\t" + "内层锁");
    }

main	外层锁
main	中层锁
main	内层锁

原理：

每个锁对象拥有一个锁计数器和一个指向持有该锁的线程的指针。

当执行monitorenter时，如果目标锁对象的计数器为零，那么说明它没有被其他线程所持有，Java虚拟机会将该锁对象的持有线程设置为当前线程，并且将其计数器加i。

在目标锁对象的计数器不为零的情况下，如果锁对象的持有线程是当前线程，那么Java虚拟机可以将其计数器加1，否则需要等待，直至持有线程释放该锁。

当执行monitorexit时，Java虚拟机则需将锁对象的计数器减1。计数器为零代表锁已被释放。

显示锁ReentrantLock验证

public static void m2(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t" + "外层锁");
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "\t" + "内层锁");
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

main	外层锁
main	内层锁

加锁和解锁两两配对，解锁多了抛异常，加锁多了出不来。

LockSupport是什么

juc.locks包下

LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。

LockSupport中的park()和unpark()的作用分别是阻塞线程和解除阻塞线程。

Object的线程等待唤醒机制(wait/notify)的升级版

在这里插入图片描述

3种让线程等待和唤醒的方法

wait&notify

方式1: 使用Object中的wait()方法让线程等待，使用Object中的notify()方法唤醒线程

细节：

wait和notify方法必须要在同步块或者方法里面且成对出现使用。

将notify放在wait方法前面，程序无法执行，无法唤醒。

    static Object objectLock = new Object();

    private static void synchronizedWaitNotify() {
        new Thread(() -> {
            synchronized (objectLock){
                System.out.println(Thread.currentThread().getName()+"\t"+"------come in");
                try {
                    objectLock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"\t"+"------被唤醒");
            }
        },"A").start();

        new Thread(() -> {
            synchronized (objectLock)
            {
                objectLock.notify();
                System.out.println(Thread.currentThread().getName()+"\t"+"------通知");
            }
        },"B").start();
    }

    public static void main(String[] args) {
        synchronizedWaitNotify();
    }


A	------come in
B	------通知
A	------被唤醒

await&signal

方式2: 使用JUC包中Condition的await()方法让线程等待，使用signal()方法唤醒线程

    static Object objectLock = new Object();

    static Lock lock = new ReentrantLock();

    static Condition condition = lock.newCondition();

    public static void main(String[] args) {

        new Thread(() -> {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "\t" + "------come in");
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "\t" + "------被唤醒");
            } finally {
                lock.unlock();
            }
        }, "A").start();


        new Thread(() -> {
            lock.lock();
            try {
                condition.signal();
                System.out.println(Thread.currentThread().getName() + "\t" + "------通知");
            } finally {
                lock.unlock();
            }
        }, "B").start();

    }


A	------come in
B	------通知
A	------被唤醒

synchronized和Lock实现等待唤醒通知的约束

线程先要获得并持有锁，必须在锁块（synchronized或lock）中，不然报异常
必须要先等待后唤醒，线程才能够被唤醒（顺序不能颠倒）

LockSupport

方式3: LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程

park等待和unpark唤醒

官网解释：

LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。

LockSupport类使用了一种名为Permit(许可)的概念来做到阻塞和唤醒线程的功能，每个线程都有一个许可(permit)

permit只有两个值1和零，默认是零。

可以把许可看成是一种(0,1)信号量(Semaphore），但与Semaphore不同的是，许可的累加上限是1。

park()方法：

阻塞当前线程/阻塞传入的具体线程

在这里插入图片描述

permit默认是0，所以一开始调用park()方法，当前线程就会阻塞，直到别的线程将当前线程的permit设置为1时, park方法会被唤醒，然后会将permit再次设置为0并返回。

unpark(Thread thread)方法：

唤醒处于阻断状态的指定线程

在这里插入图片描述

调用unpark(thread)方法后，就会将thread线程的许可permit设置成1(注意多次调用unpark方法，不会累加，permit值还是1)会自动唤醒thread线程，即之前阻塞中的LockSupport.park()方法会立即返回。

public static void main(String[] args) {
        /**
         LockSupport：俗称 锁中断
         以前的两种方式：
         1.以前的等待唤醒通知机制必须synchronized里面有一个wait和notify
         2.lock里面有await和signal
         这上面这两个都必须要持有锁才能干，
         LockSupport它的解决的痛点
         1。LockSupport不用持有锁块，不用加锁，程序性能好，
         2。不用保证2个方法的先后顺序，不容易导致卡死
         */
        Thread t1 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t ----come in "+System.currentTimeMillis());
            LockSupport.park();//阻塞当前线程
            System.out.println(Thread.currentThread().getName() + "\t ----被唤醒 "+ System.currentTimeMillis());
        }, "t1");
        t1.start();
        
        LockSupport.unpark(t1);
        System.out.println(Thread.currentThread().getName()+"\t 通知t1...");

    }

t1	 ----come in 1606459998675
main	 通知t1...
t1	 ----被唤醒 1606459998676

底层原理

LockSupport是用来创建锁和其他同步类的基本线程阻塞原语（Unsafe类的native方法）。

LockSupport是一个线程阻塞工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，阻塞之后也有对应的唤醒方法。归根结底，LockSupport调用的Unsafe中的native代码。

LockSupport提供park()和unpark()方法实现阻塞线程和解除线程阻塞的过程，LockSupport和每个使用它的线程都有一个许可(permit)关联。permit相当于1，0的开关，默认是0，调用一次unpark就加1变成1，调用一次park会消费permit，也就是将1变成0，同时park立即返回。如再次调用park会变成阻塞(因为permit为零了会阻塞在这里，一直到permit变为1)，这时调用unpark会把permit置为1。每个线程都有一个相关的permit, permit最多只有一个，重复调用unpark也不会积累凭证。

形象的理解：
线程阻塞需要消耗凭证(permit)，这个凭证最多只有1个。
当调用park方法时
*如果有凭证，则会直接消耗掉这个凭证然后正常退出;
*如果无凭证，就必须阻塞等待凭证可用;
而unpark则相反，它会增加一个凭证，但凭证最多只能有1个，累加无效。

面试题

为什么可以先唤醒线程后阻塞线程?
因为unpark获得了一个凭证，之后再调用park方法，就可以名正言顺的凭证消费，故不会阻塞。

为什么唤醒两次后阻塞两次，但最终结果还会阻塞线程?
因为凭证的数量最多为1，连续调用两次unpark和调用一次unpark效果一样，只会增加一个凭证;
而调用两次park却需要消费两个凭证，证不够，不能放行。

public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t ----come in "+System.currentTimeMillis());
            LockSupport.park();//阻塞当前线程
            System.out.println(Thread.currentThread().getName() + "\t ----被唤醒1 "+ System.currentTimeMillis());
            LockSupport.park();//阻塞当前线程
            System.out.println(Thread.currentThread().getName() + "\t ----被唤醒2 "+ System.currentTimeMillis());
        }, "t1");
        t1.start();

        TimeUnit.SECONDS.sleep(3L);

        LockSupport.unpark(t1);
        LockSupport.unpark(t1);
        System.out.println(Thread.currentThread().getName()+"\t 通知t1...");
    }

t1	 ----come in 1606460725978
main	 通知t1...
t1	 ----被唤醒1 1606460728978