【JUC】十六、LockSupport类实现线程等待与唤醒

1、LockSupport

线程等待和唤醒的方式有：

• 使用Object的wait方法让对象上活动的线程等待，使用notify方法来唤醒线程
• 使用JUC报中Condition的await方法让线程等待，使用signal方法来唤醒线程
• LockSupport类来阻塞当前线程以及唤醒指定被阻塞的线程

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

• LockSupport提供park和unpark方法实现阻塞线程和解除阻塞
• LockSupport和每个使用它的线程都有一个许可permit关联
• 每个线程都有一个相关的permit，permit最多只有一个，重复调用unpark也不会积累凭证
• LockSupport就是通过Permit (许可)的概念来做到阻塞和唤阻线程的功能

2、wait和notify存在的问题

正常使用wait和notify如下：

public class LockSupport1 {

    public static void main(String[] args) {
        Object o = new Object();
        new Thread(() -> {
            synchronized (o){
                System.out.println(Thread.currentThread().getName() + "\t come in...");
                try {
                    o.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "\t 被唤醒");
            }
        },"t1").start();
        //歇200ms
        try { TimeUnit.MILLISECONDS.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); }
        new Thread(() -> {
            synchronized (o){
                System.out.println(Thread.currentThread().getName() + "\t come in ...");
                o.notify();
                System.out.println(Thread.currentThread().getName() + "\t 发出唤醒通知");
            }

        },"t2").start();
    }
}

此时一切正常：

问题1：去掉syncyronized

问题2：先唤醒再等待

可以发现，将notify先于wait执行，等待被唤醒的线程会陷入无限等待中，就像叫你起床的人，先走了，你睡着以后没人再叫你了。

问题点总结：

• wait和notify方法必须要在同步块或者同步方法里面，且成对出现和使用
• 必须先wait再notify，反之唤醒失败

3、await和signal存在的问题

常规用法：

public class LockSupport1 {

    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        new Thread(() -> {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "\t come in...");
            try {
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
            System.out.println(Thread.currentThread().getName() + "\t 被唤醒");

        },"t1").start();
        //歇200ms
        try { TimeUnit.MILLISECONDS.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); }
        new Thread(() -> {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "\t come in...");
                condition.signal();
                System.out.println(Thread.currentThread().getName() + "\t 发出唤醒通知");
            } finally {
                lock.unlock();
            }
        },"t2").start();
    }
    
}

问题1：去掉锁

可以看到去掉lock和unlock加解锁，await和signal都触发了IllegalMonitorStateException异常。

异常2：先唤醒再等待

可以看到，前两种线程等待和唤醒的方式，都有使用限制：

• 线程必须先持有锁（synchronized或者lock）
• 必须先等待后唤醒，才能唤醒成功

4、park和unpark方法

基于前面两种方式的缺陷，LockSupport提供了新的实现思路来解决 ⇒凭证 。通过park()和unpark(thread)来实现阻塞和唤醒线程。

//阻塞当前线程
park()
//阻塞传入的具体线程
park(Thread thread)

当调用park方法时：

• 如果线程有凭证，则直接消耗掉这个凭证然后正常往下执行
• 如果线程没有凭证，就必须阻塞等待到凭证可用

看下源码，第二个参数就是用来指定多久放行的，默认0，即没许可证不放行，直到别的线程给当前线程发放permit：

unpark(Thread thread)

当调用unpark方法时：

• 给传入的线程发一个凭证
• 自动唤醒之前阻塞的LockSupport.park()
• 但凭证最多只有一个，多次调用不会累加

5、LockSupport用法示例

开两个线程t2给t1发通行证：

public class LockSupport2 {

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t ---com in: " + System.currentTimeMillis());
            LockSupport.park();
            System.out.println(Thread.currentThread().getName() + "\t ---被唤醒: " + System.currentTimeMillis());
        }, "t1");
        t1.start();
        try { TimeUnit.MILLISECONDS.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); }
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t ---com in");
            System.out.println(Thread.currentThread().getName() + "给t1线程发了permit");
            LockSupport.unpark(t1);
        },"t2").start();
    }
}

等待唤醒成功，可以发现不用锁块了，也没有synchronized或者lock了。

再看先发许可证会不会被成功唤醒：

public class LockSupport2 {

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
        	//休息两秒，让t2先执行
            try { TimeUnit.MILLISECONDS.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println(Thread.currentThread().getName() + "\t ---com in: " + System.currentTimeMillis());
            LockSupport.park();
            System.out.println(Thread.currentThread().getName() + "\t ---被唤醒: " + System.currentTimeMillis());
        }, "t1");
        t1.start();
        //try { TimeUnit.MILLISECONDS.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); }
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t ---com in");
            System.out.println(Thread.currentThread().getName() + "给t1线程发了permit");
            LockSupport.unpark(t1);
        },"t2").start();
    }
}

先发permit，再LockSupport.park()，就像持证上岗，或者高速公路的ETC，提前缴费买了通行证后走高速，遇到关卡一路通畅，此时park形同虚设

6、Permit不会累积

验证一个线程醉倒一个Permit，许可证不会累积：

public class LockSupport3 {

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            //先让发许可证的线程执行
            try { TimeUnit.MILLISECONDS.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println(Thread.currentThread().getName() + "\t ---come in");
            LockSupport.park();
            LockSupport.park();
            System.out.println(Thread.currentThread().getName() + "\t ---被唤醒");
        }, "t1");
        t1.start();
        new Thread(() -> {
            LockSupport.unpark(t1);
            LockSupport.unpark(t1);
            LockSupport.unpark(t1);
            LockSupport.unpark(t1);
        }).start();
    }
}

可以看到多次unpark也不能过两个park：

稍微再改一下，一个凭证用完后，自己再给自己发一个，就可以通过了。

7、面试

Q1：为什么LockSupport可以突破wait/notify原有的调用顺序限制？

A1：因为unpark后线程t获得了一个凭证，之后线程t再调用park，就凭证消费，畅通无阻

Q2：为什么唤醒两次后再阻塞两次，最终结果还是阻塞？

A2：因为凭证的数量最多为1，连续调用两次unpark并不会有两个凭证，而调用两次park却要消耗两个凭证，凭证不够，不能放行。