关于java:写给小白看的LockSupport

Java 并发编程系列第三篇 LockSupport，上一篇Synchronized 文章中有提过，不举荐读者们应用 Object 的wait、notify、notifyAll等函数做多线程间的通信协同，应用 LockSupport 会是更好的抉择，本篇就来谈谈 LockSupport，也正好为下篇的A Q S（AbstractQueuedSynchronized） 打基础。

LockSupport是线程工具类，次要作用是阻塞和唤醒线程，底层实现依赖 Unsafe，同时它还是锁和其余同步类实现的根底，LockSupport 提供两类动态函数别离是 park 和unpark，即阻塞与唤醒线程，上面是两段代码示例

示例 -1

    public static void main(String[] agrs) throws InterruptedException {Thread th = new Thread(() -> {
            // 阻塞以后线程
            LockSupport.park();
            System.out.println("子线程执行 ---------");
        });
        th.start();
        // 睡眠 2 秒
        Thread.sleep(2000);
        System.out.println("主线程执行 ---------");
        // 唤醒线程
        LockSupport.unpark(th);
    }
}


输入后果：主线程执行 ---------
子线程执行 ---------

上述示例中，子线程 th 调用 LockSupport.park() 阻塞，主线程睡眠 2 秒后，执行 LockSupport.unpark(th) 唤醒 th 线程，先阻塞后唤醒十分好了解，接下来读者们再看上面的示例

示例 -2

    public static void main(String[] agrs) throws InterruptedException {Thread th = new Thread(() -> {
            // 唤醒以后线程
            LockSupport.unpark(Thread.currentThread());
            // 阻塞以后线程
            LockSupport.park();
            System.out.println("子线程执行 ---------");
        });
        th.start();
        // 睡眠 2 秒
        Thread.sleep(2000);
        System.out.println("主线程执行 ---------");
    }



输入后果：子线程执行 ---------
主线程执行 ---------

嗯？先唤醒 th 线程，再阻塞 th 线程，最终 th 线程没有被阻塞，这是为什么？上面 LockSupport 的设计思路会为读者们解开纳闷，并更进一步明确是 park 和unpark的语义（从狭义上来说 park 和unpark代表阻塞和唤醒）。

LockSupport的设计思路是通过许可证来实现的，就像汽车上高速公路，入口处要获取通行卡，出口处要交出通行卡，如果没有通行卡你就无奈出站，当然你能够抉择补一张通行卡。

LockSupport会为应用它的线程关联一个许可证（permit）状态，permit的语义「是否领有许可」，0代表否，1代表是，默认是0。

LockSupport.unpark：指定线程关联的 permit 间接更新为1，如果更新前的permit<1，唤醒指定线程
LockSupport.park：以后线程关联的 permit 如果 >0，间接把permit 更新为0，否则阻塞以后线程

线程 A 执行 LockSupport.park，发现permit 为0，未持有许可证，阻塞线程A
线程 B 执行 LockSupport.unpark（入参线程A），为A 线程设置许可证，permit更新为1，唤醒线程A
线程 B 流程完结
线程 A 被唤醒，发现 permit 为1，生产许可证，permit更新为0
线程 A 执行临界区
线程 A 流程完结

通过下面的剖析得出结论 unpark 的语义明确为「使线程持有许可证 」，park 的语义明确为「生产线程持有的许可 」，所以unpark 与park的执行程序没有强制要求，只有管制好应用的线程即可，unpark=>park执行流程如下

permit默认是 0，线程A 执行 LockSupport.unpark，permit 更新为 1，线程A 持有许可证
线程 A 执行 LockSupport.park，此时permit 是1，生产许可证，permit更新为0
执行临界区
流程完结

最初再补充下 park 留神点，因 park 阻塞的线程不仅仅会被 unpark 唤醒，还可能会被线程中断（Thread.interrupt）唤醒，而且不会抛出 InterruptedException 异样，所以倡议在 park 后自行判断 线程中断状态，来做对应的业务解决。

为什么举荐应用 LockSupport 来做线程的阻塞与唤醒（线程间协同工作），因为它具备如下长处

以线程为操作对象更合乎阻塞线程的直观语义
操作更精准，能够精确地唤醒某一个线程（notify随机唤醒一个线程，notifyAll唤醒所有期待的线程）
无需竞争锁对象（以线程作为操作对象），不会因竞争锁对象产生死锁问题
unpark与 park 没有严格的执行程序，不会因执行程序引起死锁问题，比方「Thread.suspend和Thread.resume」没依照严格程序执行，就会产生死锁

另外 LockSupport 还提供了 park 的重载函数，晋升灵活性

void parkNanos(long nanos)：减少了超时机制
void parkUntil(long deadline)：退出超时机制（指定到某个工夫点，1970年到指定工夫点的毫秒数）
void park(Object blocker)：设置 blocker 对象，当线程没有许可证被阻塞时，该对象会被记录到该线程的外部，不便后续应用诊断工具进行问题排查
void parkNanos(Object blocker, long nanos)：设置 blocker 对象，退出超时机制
void parkUntil(Object blocker, long deadline)：设置 blocker 对象，退出超时机制（指定到某个工夫点，1970年到指定工夫点的毫秒数）

倡议应用时，传入 blocker 对象，至于超时依据业务场景抉择

应用 LockSupport 来实现一道阿里经典的多线程协同工作面试题。

有 3 个独立的线程，一个只会输入A，一个只会输入B，一个只会输入C，在三个线程启动的状况下，请用正当的形式让他们按程序打印ABCABC。

思路如下

筹备 3 个线程，别离固定打印A、B、C
线程输入完 A、B、C 后须要阻塞期待唤醒
额定筹备第 4 个线程，作为另外 3 个线程的调度器，有序的管制 3 个线程执行

是不是很简略，上面通过代码来实际

    public static void main(String[] agrs) throws InterruptedException {LockSupportMain lockSupportMain = new LockSupportMain();
        
        // 定义线程 t1、t2、t3 执行的函数办法
        Consumer<String> consumer = str -> {while (true) {
                // 线程生产许可证，并传入 blocker，不便后续排查问题
                LockSupport.park(lockSupportMain);
                // 避免线程是因中断操作唤醒
                if (Thread.currentThread().isInterrupted()){throw new RuntimeException("线程被中断，异样完结");
                }
                System.out.println(Thread.currentThread().getName() + ":" + str);
            }
        };
        
        /**
         * 定义别离输入 A、B、C 的线程
         */
        Thread t1 = new Thread(() -> {consumer.accept("A");
        },"T1");
        Thread t2 = new Thread(() -> {consumer.accept("B");
        },"T2");
        Thread t3 = new Thread(() -> {consumer.accept("C");
        },"T3");

        
        /**
         * 定义调度线程
         */
        Thread dispatch = new Thread(() -> {
            int i=0;
            try {while (true) {if((i%3)==0) {
                        // 线程 t1 设置许可证，并唤醒线程 t1
                        LockSupport.unpark(t1);
                    }else if((i%3)==1) {
                        // 线程 t2 设置许可证，并唤醒线程 t2
                        LockSupport.unpark(t2);
                    }else {
                        // 线程 t3 设置许可证，并唤醒线程 t3
                        LockSupport.unpark(t3);
                    }
                    i++;
                    TimeUnit.MILLISECONDS.sleep(500);
                }
            } catch (InterruptedException e) {e.printStackTrace();
            }
        });

        // 启动相干线程
        t1.start();
        t2.start();
        t3.start();
        dispatch.start();}


输入内容：T1:A
T2:B
T3:C
T1:A
T2:B
T3:C
T1:A
T2:B
T3:C

最初再留个题目给读者们思考，应用蕴含但不限于 Synchronized、ReentrantLock 来实现这个性能

LockSupport非常简略好用，是作为并发编程的必备根底，阿星感觉是非常有必要把握的，所以出了这篇文章，后续的打算安顿 AbstractQueuedSynchronizer、ReentrantLock、ReentrantReadWriteLock 文章，大略两周内出一篇，因为最近公司业务比较忙，所以周更有点艰难，然而阿星会尽力做到周更，如果感觉阿星的文章对您有帮忙，也请一键三连反对阿星（点赞、再看、转发）

13 张图，深刻了解 Synchronized
由浅入深 CAS，小白也能与 BAT 面试官对线
小白也能看懂的 Java 内存模型
保姆级教学，22 张图揭开 ThreadLocal
过程、线程与协程傻傻分不清？一文带你吃透！
什么是线程平安？一文带你深刻了解

这里是阿星，一个酷爱技术的 Java 程序猿，公众号 <span style=”color: Blue;”>「程序猿阿星」</span> 里将会定期分享操作系统、计算机网络、Java、分布式、数据库等精品原创文章，2021，与您在 Be Better 的路上独特成长！。

非常感谢各位小哥哥小姐姐们能看到这里，原创不易，文章有帮忙能够关注、点个赞、分享与评论，都是反对（莫要白嫖）！

愿你我都能奔赴在各自想去的路上，咱们下篇文章见

前言

内容纲要

LockSupport 基本概念

设计思路

长处

实际

唠叨唠叨

历史好文举荐

对于我