关于java:写给小白看的LockSupport

前言

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

内容纲要

LockSupport基本概念

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

示例-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的设计思路会为读者们解开纳闷,并更进一步明确是parkunpark的语义(从狭义上来说parkunpark代表阻塞和唤醒)。

设计思路

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

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

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

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

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

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

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

长处

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

  • 以线程为操作对象更合乎阻塞线程的直观语义
  • 操作更精准,能够精确地唤醒某一个线程(notify随机唤醒一个线程,notifyAll唤醒所有期待的线程)
  • 无需竞争锁对象(以线程作为操作对象),不会因竞争锁对象产生死锁问题
  • unparkpark没有严格的执行程序,不会因执行程序引起死锁问题,比方「Thread.suspendThread.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

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

唠叨唠叨

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

历史好文举荐

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

对于我

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

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

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

【腾讯云】轻量 2核2G4M,首年65元

阿里云限时活动-云数据库 RDS MySQL  1核2G配置 1.88/月 速抢

本文由乐趣区整理发布,转载请注明出处,谢谢。

您可能还喜欢...

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注

此站点使用Akismet来减少垃圾评论。了解我们如何处理您的评论数据