JUC02-多线程锁、线程中断机制、LockSupport线程间通信

已于 2023-07-16 01:33:59 修改
阅读量320 收藏
点赞数
分类专栏： JUC并发编程 文章标签： 开发语言 java java-ee
于 2023-07-16 01:25:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62176282/article/details/131746356
版权

文章目录

JUC02

课程任务概览

本部分包含：

  • 多线程锁各种锁的概览

    • 获得所得流程

  • 线程中断机制

  • LockSupport的pork替换wait和await方法

多线程锁

悲观锁和乐观锁

  • 悲观锁

    • 显式的锁定之后再操作同步资源

    • 适合写操作多的场景，先加锁可以保证写操作时数据正确。

    • synchronized关键字和lock的实现类都是采用悲观锁

  • 乐观锁

  • 认为自己在使用数据时不会有别的线程修改数据或资源，所以不会添加锁。

  • 在Java中是通过使用无锁编程来实现，只是在更新数据的时候去判断，之前有没有别的线程更新了这个数据。

    • 如果这个数据没有被更新，当前线程将自己修改的数据成功写入。

    • 如果这个数据己经被其它线程更新，则根据不同的实现方式执行不同的操作，比如放弃修改、重试抢锁等等

  • 判断规则

    • 1 版本号机制Version

    • 2 最常采用的是CAS算法，Java原子类中的递增操作就通过CAS自旋实现的。

  • 适合读操作多的场景，不加锁的特点能够使其读操作的性能大幅提升。

synchronized

synchronized 8锁案例演示

阿里开发手册：

【强制】高并发时，同步调用应该去考量锁的性能损耗。能用无锁数据结构，就不要用锁；能锁区块，就不要锁整个方法体；能用对象锁，就不要用类锁。

说明：尽可能使加锁的代码块工作量尽可能的小，避免在锁代码块中调用RPC方法。

先说结论：

  • 作用于实例方法，当前实例加锁，进入同步代码前要获得当前实例的锁；
  • 作用于代码块，对括号里配置的对象加锁。
  • 作用于静态方法，当前类加锁，进去同步代码前要获得当前类对象的锁；

案例演示：

//资源类
class Phone {
    public static synchronized void sendEmail() {
        try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}
        System.out.println("-----sendEmail");
    }

    public synchronized void sendSMS() {
        System.out.println("-----sendSMS");
    }

    public void hello() {
        System.out.println("-------hello");
    }
}

/**
 * 题目：谈谈你对多线程锁的理解,8锁案例说明
 * 口诀：线程   操作  资源类
 * 8锁案例说明：
 * 1 标准访问有ab两个线程，请问先打印邮件还是短信
 * 2 sendEmail方法中加入暂停3秒钟，请问先打印邮件还是短信
 * 3 添加一个普通的hello方法，请问先打印邮件还是hello
 * 4 有两部手机，请问先打印邮件还是短信
 * 5 有两个静态同步方法，有1部手机，请问先打印邮件还是短信
 * 6 有两个静态同步方法，有2部手机，请问先打印邮件还是短信
 * 7 有1个静态同步方法，有1个普通同步方法,有1部手机，请问先打印邮件还是短信
 * 8 有1个静态同步方法，有1个普通同步方法,有2部手机，请问先打印邮件还是短信
 * <p>
 * 笔记总结：
 * 1-2
 * 一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了，
 * 其它的线程都只能等待，换句话说，某一个时刻内，只能有唯一的一个线程去访问这些synchronized方法
 * 锁的是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的synchronized方法
 * 3-4
 * 加个普通方法后发现和同步锁无关
 * 换成两个对象后，不是同一把锁了，情况立刻变化。
 * <p>
 * 5-6 都换成静态同步方法后，情况又变化
 * 三种 synchronized 锁的内容有一些差别:
 * 对于普通同步方法，锁的是当前实例对象，通常指this,具体的一部部手机,所有的普通同步方法用的都是同一把锁——>实例对象本身，
 * 对于静态同步方法，锁的是当前类的Class对象，如Phone.class唯一的一个模板
 * 对于同步方法块，锁的是 synchronized 括号内的对象
 * <p>
 * 7-8
 * 当一个线程试图访问同步代码时它首先必须得到锁，正常退出或抛出异常时必须释放锁。
 * <p>
 * 所有的普通同步方法用的都是同一把锁——实例对象本身，就是new出来的具体实例对象本身,本类this
 * 也就是说如果一个实例对象的普通同步方法获取锁后，该实例对象的其他普通同步方法必须等待获取锁的方法释放锁后才能获取锁。
 * <p>
 * 所有的静态同步方法用的也是同一把锁——类对象本身，就是我们说过的唯一模板Class
 * 具体实例对象this和唯一模板Class，这两把锁是两个不同的对象，所以静态同步方法与普通同步方法之间是不会有竞态条件的
 * 但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁。
 */
public class Lock8Demo {
    //一切程序的入口
    public static void main(String[] args) {
        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "a").start();

        //暂停毫秒,保证a线程先启动
        try {TimeUnit.MILLISECONDS.sleep(200);} catch (InterruptedException e) {e.printStackTrace();}

        new Thread(() -> {
            //phone.sendSMS();
            //phone.hello();
            phone2.sendSMS();
        }, "b").start();
    }
}

synchronized字节码分析

编译后找到项目下out文件夹，从需要反编译的文件处打开终端，使用以下命令进行反编译 .class 文件：

javap -c ****.class

//假如你需要更多信息
javap -v ****.class

1 synchronized同步代码块

  • 实现使用的是monitorenter和monitorexit指令

  • 一般情况就是1个enter对应2个exit

    • 当正常处理时会有一个monitorexit，考虑到当发生异常时，也应该有一个monitorexit

  • 极端情况下：m1方法里面自己添加一个异常，只会有一个exit

一般情况下：

image-20230714154848428

自己添加异常

image-20230714154932879

2 synchronized普通同步方法

  • 调用指令将会检查方法的ACC_SYNCHRONIZED访问标志是否被设置如果设置了，执行线程会将先持有monitor锁，然后再执行方法，最后在方法完成（无论是正常完成还是非正常完成）时释放monitor

image-20230714155624251

3 synchronized静态同步方法

  • 调用指令将会检查方法的ACC_STATIC和ACC_SYNCHRONIZED访问标志是否被设置如果设置了

123321

为什么任何一个对象都可以成为一个锁？

image-20230714165537334

123

公平锁和非公平锁

  • 公平锁

    • 是指多个线程按照申请锁的顺序来获取锁，这里类似排队买票，先来的人先买后来的人在队尾排着，这是公平的

    • Lock lock=new ReentrantLock(true);//true表示公平锁，先来先得

  • 非公平锁

    • 多个线程抢占锁，有可能后申请的线程比先申请的线程优先获取锁，在高并发环境下，有可能造成优先级翻转或者饥饿的状态（某个线程一直得不到锁）
    • Lock lock=new ReentrantLock(false);//false表示非公平锁，后来的也可能先获得锁
    • Lock lock=new ReentrantLock();//默认非公平锁
为什么会有公平锁/非公平锁的设计？为什么默认非公平？

恢复挂起的线程到真正锁的获取还是有时间差的，从开发人员来看这个时间微乎其微，但是从CPU的角度来看，这个时间差存在的还是很明显的。

所以非公平锁能更充分的利用CPU的时间片，尽量减少CPU空闲状态时间。

使用多线程很重要的考量点是线程切换的开销，当采用非公平锁时，当1个线程请求锁获取同步状态，然后释放同步状态，所以刚释放锁的线程在此刻再次获取同步状态的概率就变得非常大，所以就减少了线程的开销。

可重入锁（递归锁）

可重入锁又名递归锁

  • 是指在同一个线程在外层方法获取锁的时候，再进入该线程的内层方法会自动获取锁（前提，锁对象得是同一个对象），不会因为之前已经获取过还没释放而阻塞。
  • 如果是1个有synchronized修饰的递归调用方法，程序第2次进入被自己阻塞了岂不是天大的笑话，出现了作茧自缚。
  • 所以Java中ReentrantLock和synchronized都是可重入锁，可重入锁的一个优点是可一定程度避免死锁。

隐式锁：即synchronized使用的锁

  • 指的是可重复可递归调用的锁，在外层使用锁之后，在内层仍然可以使用，并且不发生死锁，这样的锁就叫做可重入锁。
  • 简单的来说就是：在一个synchronized修饰的方法或代码块的内部调用本类的其他synchronized修饰的方法或代码块时，是永远可以得到锁的

显式锁：即ReentrantLock

  • 需要显示指定

  • lock几次，就需要unlock几次，否则会让其他线程无法获得锁造成卡死

Synchronized的重入的实现机理

  • 每个锁对象拥有一个锁计数器（_count 和 _recursions）和一个指向持有该锁的线程的指针（_owner）。（记录在对象的对象头中）
  • 当执行monitorenterl时，如果目标锁对象的_count 为零，那么说明它没有被其他线程所持有，Java虚拟机会将该锁对象的持有线程设置为当前线程，并且将其计数器加1。
  • 在目标锁对象的计数器不为零的情况下，如果锁对象的持有线程是当前线程，那么Java虚拟机可以将其计数器加1，否则需要等待，直至持有线程释放该锁。
  • 当执行monitorexit指令时，Java虚拟机则需将锁对象的计数器减1。计数器为零代表锁已被释放。

具体全部过程可在小总结中查看

可重入锁案例演示

public class SyncLockDemo {

    public synchronized void add() {
        add();
    }

    public static void main(String[] args) {
        /**
         * 可重入锁（递归锁）：多层锁机制只需要同一把锁即可自由出入
         * synchronized(隐式)    lock(显式)
         */
        //synchronized可重入锁演示1：
        Object o = new Object();
        new Thread(() -> {
            synchronized (o){
                System.out.println(Thread.currentThread().getName() + "外层");

                synchronized (o){
                    System.out.println(Thread.currentThread().getName() + "中层");

                    synchronized (o){
                        System.out.println(Thread.currentThread().getName() + "内层");
                    }
                }
            }
        },"t1").start();


        //synchronized可重入锁演示2：
        new SyncLockDemo().add();   //将会报栈内存溢出，证明可以递归调用add方法自己，是可重入锁
    }

    /**
     * lock演示可重入锁       递归使用锁必须一上锁对应一解锁，加入内部锁上锁了不解锁，自己线程使用会没问题，但是会影响其它线程
     */
    @Test
    public void testLock() {
        Lock lock = new ReentrantLock();
        new Thread(() -> {
            try {
                lock.lock();
                System.out.println(Thread.currentThread().getName() + " 外层");

                try {
                    //上锁
                    lock.lock();
                    System.out.println(Thread.currentThread().getName() + " 内层");
                } finally {
                    //释放锁
                    lock.unlock();
                }
            } finally {
                lock.unlock();
            }
        }, "t1").start();

    }
}

死锁

死锁是指两个或两个以上的线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力干涉那它们都将无法推进下去，如果系统资源充足，进程的资源请求都能够得到满足，死锁出现的可能性就很低，否则就会因争夺有限的资源而陷入死锁。

排查死锁

  • jps -l
jstack 进程id

  • 使用jconsole -> 线程 -> 检测死锁

image-20230711160927379

手写一个死锁案例

/**
 * 死锁：两个或者两个以上进程在执行过程中，因为争夺资源而造成一种互相等待的现象，如果设有外力干涉，他们无法再执行下去
 * 
 * 死锁的验证方式：第一步：jps  第二步：jstack 进程号
 */
public class DeadLockDemo {
    
    //先创建两个对象充当两把锁
    static Object a = new Object();
    static Object b = new Object();

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (a){
                System.out.println(Thread.currentThread().getName() + "持有锁a，试图获取锁b");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (b){
                    System.out.println(Thread.currentThread().getName() + "获取锁b");
                }
            }
        },"A").start();

        new Thread(() -> {
            synchronized (b){
                System.out.println(Thread.currentThread().getName() + "持有锁b，试图获取锁a");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (a){
                    System.out.println(Thread.currentThread().getName() + "获取锁a");
                }
            }
        },"B").start();
    }

小总结：获得锁的全流程（重要）

指针指向monitor对象（也称为管程或监视器锁）的起始地址。每个对象都存在着一个monitor与之关联，当一个monitor被某个线程持有后，它便处于锁定状态。在Java虚拟机(HotSpot)中，monitor是由ObjectMonitor实现的，其主要数据结构如下（位于HotSpot虚拟机源码ObjectMonitor.hpp文件，C++实现的）

ObjectMonitor.hpp在目录 为什么任何一个对象都可以成为一个锁？ 中提到过

image-20230714170452735

LockSupport与线程中断

中断机制

什么是中断机制？

首先

一个线程不应该由其他线程来强制中断或停止，而是应该由线程自己自行停止，自己来决定自己的命运。

所以，Thread.stop,Thread.suspend,Thread.resume都己经被废弃了。

其次

在Java中没有办法立即停止一条线程，然而停止线程却显得尤为重要，如取消一个耗时操作。

因此，Java提供了一种用于停止线程的协商机制——中断，也即中断标识协商机制。

中断只是一种协作协商机制，Java没有给中断增加任何语法，中断的过程完全需要程序员自己实现。

若要中断一个线程，你需要手动调用该线程的interrupt方法，该方法也仅仅是将线程对象的中断标识设成true;

接着你需要自己写代码不断地检测当前线程的标识位，如果为tue,表示别的线程请求这条线程中断，

此时究竞该做什么需要你自己写代码实现。

每个线程对象中都有一个中断标识位，用于表示线程是否被中断；该标识位为tue表示中断，为false表示未中断：

通过调用线程对象的interrupt方法将该线程的标识位设为true;可以在别的线程中调用，也可以在自己的线程中调用。

中断机制API 的三大方法

总述

public void interrupt()实例方法，Just to set the interrupt
实例方法interrupt()仅仅是设置线程的中断状态为true，发起一个协商而不会立刻停止线程
public static boolean interrupted()静态方法，Thread.interrupted();
判断线程是否被中断并清除当前中断状态。
这个方法做了两件事：
1返回当前线程的中断状态，测试当前线程是否已被中断
2将当前线程的中断状态清零并重新设为false,清除线程的中断状态

如果连续两次调用此方法，则第二次调用将返回false,因为连续调用两次的结果可能不一样
public boolean isInterrupted()实例方法，
判断当前线程是否被中断（通过检查中断标志位）

interrupt()详解与演示

具体来说，当对一个线程，调用interrupt()时：

  • ①如果线程处于正常活动状态，那么会将该线程的中断标志设置为tue,仅此而已。

​ 被设置中断标志的线程将继续正常运行，不受影响。

​ 所以，interrupt)(并不能真正的中断线程，需要被调用的线程自己进行配合才行。

​ 若线程结束，中断标志会被重置，即false

​ 中断只是一种协商机制，修改中断标识位仅此而己，不是立刻stop打断

  • ②如果线程处于被阻塞状态（例如处于sleep,wait,join等状态），在别的线程中调用当前线程对象的interrupt方法，

​ 那么线程将立即退出被阻塞状态，中断标志被清空为false，并抛出一个InterruptedException异常，导致无限循环。

​ 需要在异常处理catch中再次调用interrupt()

正常活动状态案例演示

/**
 * 正常活动状态案例演示
 */
public class InterruptDemo2 {
    public static void main(String[] args) {
        //实例方法interrupt()仅仅是设置线程的中断状态位设置为true，不会停止线程
        Thread t1 = new Thread(() -> {
            for (int i = 1; i <= 300; i++) {
                System.out.println("-----: " + i);
            }
            System.out.println("t1线程调用interrupt()后的的中断标识02：" + Thread.currentThread().isInterrupted());
        }, "t1");
        t1.start();

        System.out.println("t1线程默认的中断标识：" + t1.isInterrupted());//false

        //暂停毫秒
        try {
            TimeUnit.MILLISECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t1.interrupt();//true
        System.out.println("t1线程调用interrupt()后的的中断标识01：" + t1.isInterrupted());//true
        
        try {TimeUnit.MILLISECONDS.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}
        System.out.println("t1线程调用interrupt()后的的中断标识03：" + t1.isInterrupted());//????---false中断不活动的线程不会产生任何影响。
    }
}

...
t1线程调用interrupt()后的的中断标识01：true
...
t1线程调用interrupt()后的的中断标识02：true
t1线程调用interrupt()后的的中断标识03：false

被阻塞状态案例演示

/**
 * 1 中断标志位，默认false
 * 2 t2 ----> t1发出了中断协商，t2调用t1.interrupt()，中断标志位true
 * 3 中断标志位true，正常情况，程序停止，^_^
 * 4 中断标志位true，异常情况，InterruptedException，将会把中断状态将被清除，并且将收到InterruptedException 。中断标志位false
 *    导致无限循环
 *
 * 5 在catch块中，需要再次给中断标志位设置为true，2次调用停止程序才OK
 */
public class InterruptDemo3 {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (true) {
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println(Thread.currentThread().getName() + "\t " +
                            "中断标志位：" + Thread.currentThread().isInterrupted() + " 程序停止");
                    break;
                }
                //设置线程为阻塞状态，即上述第4点
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();//需要再次自己在catch中调用interrupt()，否则无限循环
                    e.printStackTrace();
                }
                System.out.println("----------hello InterruptDemo3");
            }
        }, "t1");
        
        t1.start();
        
        try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}
        
        new Thread(() -> t1.interrupt(),"t2").start();
    }
}

interrupted()相较于isInterrupted()

image-20230714211323669

可以看到两个方法底层都是调用同一份native方法，“中断状态将会根据传入的Clearlnterrupted参数值确定是否重置”。

  • 所以，静态方法interrupted将会清除中断状态（传入的参数Clearlnterrupted为true),
  • 实例方法isInterrupted则不会（传入的参数Clearlnterrupted.为false)。

案例演示

public class InterruptDemo4 {
    public static void main(String[] args) {
        //测试当前线程是否被中断（检查中断标志），返回一个boolean并清除中断状态，
        // 第二次再调用时中断状态已经被清除，将返回一个false。
        System.out.println(Thread.currentThread().getName() + "\t" + Thread.interrupted());
        System.out.println(Thread.currentThread().getName() + "\t" + Thread.interrupted());
        System.out.println("----1");
        Thread.currentThread().interrupt();// 中断标志位设置为true
        System.out.println("----2");
        System.out.println(Thread.currentThread().getName() + "\t" + Thread.interrupted());
        System.out.println(Thread.currentThread().getName() + "\t" + Thread.interrupted());
    }
}

false
false
true
false

中断或停止运行中的线程的方法

通过volatile或AtomicBoolean实现停止

/**
 * 通过volatile或AtomicBoolean实现中断停止线程
 */
public class InterruptDemo {
    static volatile boolean isStop = false;
    static AtomicBoolean atomicBoolean = new AtomicBoolean(false);
    
    public static void main(String[] args) {
        new Thread(() -> {
            while (true) {
                if (atomicBoolean.get()){
                    System.out.println(Thread.currentThread().getName() + "\t atomicBoolean 被修改未true，程序停止");
                    break;
                }
                System.out.println("t1---------hello atomicBoolean");
            }
        },"t1").start();

        try {TimeUnit.MILLISECONDS.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}

        new Thread(() -> {
            atomicBoolean.set(true);
        },"t2").start();
    }

    private static void m1_volatile() {
        new Thread(() -> {
            while (true) {
                if (isStop){
                    System.out.println(Thread.currentThread().getName() + "\t isStop 被修改未true，程序停止");
                    break;
                }
                System.out.println("t1---------hello volatile");
            }
        },"t1").start();

        try {TimeUnit.MILLISECONDS.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}

        new Thread(() -> {
            isStop = true;
        },"t2").start();
    }
}

通过interrupt实现中断

Thread t1 = new Thread(() -> {
    while (true) {
        if (Thread.currentThread().isInterrupted()) {
            System.out.println(Thread.currentThread().getName() + "\t isInterrupted() 被修改为true，程序停止");
            break;
        }
        System.out.println("t1---------hello isInterrupted()");
    }
}, "t1");
t1.start();

try {TimeUnit.MILLISECONDS.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}

new Thread(() -> {
    t1.interrupt();
},"t2").start();

如何中断或停止一个运行中的线程？

312-321

停止：

  • 使用volatile或AtomicBoolean时，将他们的变量或实例设置为true，让线程中断
  • 线程自己自行停止是否停止线程，自己来决定自己的命运。所以，Thread.stop,Thread.suspend,Thread.resume都己经被废弃了。

中断：

  • 使用interrupt()方法设置中断标志为true，并由线程自己配合进行中断停止

LockSupport

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

让线程等待和唤醒的方法

即实现线程间通信的方法

  • 方式1：使用Object中的wait()方法让线程等待，使用Object中的notify()方法唤醒线程
    • wait方法和notify方法，两个都必须放在同步代码块内，否则抛出异常
    • 先执行notify，再执行wait方法时，程序无法继续执行，wait线程无法被唤醒
  • 方式2：使用JUC包中Condition的ait()方法让线程等待，使用signal()方法唤醒线程
    • await方法和signal方法，两个都必须放在同步代码块内，否则抛出异常
    • 先执行signal，再执行await方法时，程序无法继续执行，wait线程无法被唤醒
  • 方式3：LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程
    • 解决上面两种方法的问题
    • 凭证最多只能有1个，累加无效，只能调用一对park()和unpark()
    • 在同步方法中时，park()不会释放锁，而上面方法的wait()是会释放锁的

使用Object和Condition的限制条件

  • 线程先要获得并持有锁，必须在锁块（synchronized或Iock）中
  • 必须要先等待后唤醒，线程才能够被唤醒

案例演示：

/**
 * Object的wait()演示：
 * 1 在同步代码块中先wait再notify：下程序正常运行
 * 2 没有同步代码块：报异常
 * 3 在同步代码块中先notify再wait：wait线程不能被唤醒
 */
private static void syncWaitNotify() {
    Object objectLock = new Object();

    new Thread(() -> {
        //try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
        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 ----被唤醒");
        }
    },"t1").start();

    //暂停几秒钟线程
    try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

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

/**
 * Condition的await()演示：
 * 1 在同步代码块中先await再signal：下程序正常运行
 * 2 没有同步代码块：报异常
 * 3 在同步代码块中先ignal再await：await线程不能被唤醒
 */
private static void lockAwaitSignal() {
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

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

    //暂停几秒钟线程
    try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

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

使用LockSupport

park()方法源码

public static void park() {
    UNSAFE.park(false, 0L);
}

permiti许可证默认没有不能放行，所以一开始调park()方法当前线程就会阻塞，直到别的线程给当前线程的发放permit,park方法才会被唤醒。

unpark()方法源码

public static void unpark(Thread thread) {
    if (thread != null)
        UNSAFE.unpark(thread);
}

调用unpark(thread)方法后，就会将thread线程的许可证permit发放，会自动唤醒park线程，即之前阻塞中的LockSupport.park()方法会立即返回。

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

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

LockSupport提供park()和unpark()方法实现阻塞线程和解除线程阻塞的过程

LockSupport和每个使用它的线程都有一个许可(permit)关联：

每个线程都有一个相关的permit，线程阻塞需要消耗凭证(permit)，这个凭证最多只有1个。permiti最多只有一个，重复调用unpark也不会积累凭证。

当调用park()方法时

  • 如果有凭证，则会直接消耗掉这个凭证然后正常退出：
  • 如果无凭证，就必须阻塞等待凭证可用：

而unpark()则相反，它会增加一个凭证，但凭证最多只能有1个，累加无效。

优缺点总结：

  • 解决上面两种方法的问题
  • 凭证最多只能有1个，累加无效，只能调用一对park()和unpark()
  • 在同步方法中时，park()不会释放锁，而上面方法的wait()是会释放锁的

为什么可以突破wait/notify的原有调用顺序？

因为unpark获得了一个凭证，之后再调用pak方法，就可以名正言顺的凭证消费，故不会阻塞。

先发放了凭证后续可以畅通无阻。

为什么唤醒两次后阻塞两次，但最终结果还会阻塞线程？

因为凭证的数量最多为1，连续调用两次unpark和调用一次unpark效果一样，只会增加一个凭证；

而调用两次park却需要消费两个凭证，证不够，不能放行。

案例演示

/**
 * LockSupport的park()演示：
 * 解决其它两个办法的问题
 * 但是：
 *  凭证最多只能有1个，累加无效，只能调用一对park()和unpark()
 *  在同步方法中时，park()不会释放锁，而上面方法的wait()是会释放锁的
 */
public static void main(String[] args) {
    Thread t1 = new Thread(() -> {
        try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
        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();

    //暂停几秒钟线程
    //try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

    new Thread(() -> {
        LockSupport.unpark(t1);
        System.out.println(Thread.currentThread().getName()+"\t ----发出通知");
    },"t2").start();
}
spongehah
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
thread.zip--狂神多线程+juc
03-18
B站狂神说Java的多线程基础篇+juc高级篇代码
JUC之LockSupport-多线程与高并发
phs999的博客
10-12 175
LockSupport的意思就是有个变量控制线程的是否阻塞。对应有两个方法park()和unpark(thread)。park()是说当前线程执行该方法后进入阻塞状态，需要再调用unpark(thread)解除阻塞限制。如果unpark(thread)先于park()执行，则该次park()不起作用不会使得线程阻塞。 package basic.aqs.LockSupport; import java.util.concurrent.TimeUnit; import java.util.concurr
Java——聊聊JUC中的线程中断机制 & LockSupport
胜天半子祁同伟
09-14 3712
Java——聊聊JUC中的线程中断机制 & LockSupport
Java多线程Day22-JUC锁之LockSupport
攻城狮Chova的博客
05-13 278
LockSupport
四、LockSupport与线程中断
余笙的博客
08-22 284
interrupt底层调用Unsafe中的native代码线程首先要获得并持有锁，必须在synchronized或lock中。
JUC多线程学习个人笔记
07-08
锁机制：JUC提供了Lock接口和Condition接口，可以实现更细粒度的锁控制和线程的等待和唤醒机制。 并发工具类：JUC提供了一些并发编程的工具类，如Semaphore、CountDownLatch、CyclicBarrier等，可以实现线程间的协作...
JUC代码演示 Java多线程并发
05-03
JUC代码演示 Java多线程并发 源于B站https://www.bilibili.com/video/BV1Kw411Z7dF/?p=32&spm_id_from=333.1007.top_right_bar_window_history.content.click课程自我项目记录。 适合有一定基础的朋友。
Java 多线程与并发(9-26)-JUC锁- LockSupport详解.pdf
07-23
Java 多线程与并发(9_26)-JUC锁_ LockSupport详解
多线程基础、JUC锁、同步容器、线程池
07-11
多线程基础、JUC锁、同步容器、线程池
从需求角度介绍PasteSpider(K8S平替部署工具适合于任何开发语言)
05-14 1093
Kubernetes的强大毋庸置疑，但是你有问自己这么个大杀器真的适合你么？这里推荐一款更加小巧的容器部署工具，集报表，发布，环境，通知于一身的PasteSpider! 支持git/svn发布，支持平滑升级，支持环境隔离，支持用户隔离，支持运行变量设定等，关键易上手！
jar包增量更新分析
junlaiyan的专栏
05-16 249
借助jdeps分析出jar包的增量文件
java实现拼图小游戏
monkey108的博客
05-16 614
本文主要提供用java实现的拼图小游戏源代码。
命令执行漏洞（二）
XLbb的博客
05-15 899
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 898
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
java数据结构与算法(验证二叉搜索树)
磐门的博客
05-17 244
节点返回空为ture,节点的值不在对应数据大小范围内返回false。将验证二叉搜索树计算同样可以转换为相同子问题，所以比较适合用递归。node为root的左节点时，max更新为root.val。node为root的右节点时，min更新为root.val。
Kubernetes 审计日志采集与分析最佳实践
观测云的博客
05-17 1020
​Kubernetes 在 1.7 版本中发布了审计（Audit）日志功能，通过审计日志，我们能够非常清晰的知道 K8S 集群到底发生了什么事情。
java导出excel动态加载多sheet多复杂表头
weixin_43931108的博客
05-14 247
java导出excel动态加载多sheet多复杂表头
解决 SpringBoot 的 Date、LocalDateTime 变成时间戳和数组的问题，创建自定义对象消息转换器
最新发布
shijialeya
05-18 373
解决 SpringBoot 的 Date、LocalDateTime 变成时间戳和数组的问题，创建自定义对象消息转换器进行数据格式化。
java多线程锁面试题
09-21
Java多线程中的锁有两类，分别是synchronized关键字和Lock接口。synchronized关键字是Java中最基本的线程同步机制，通过在方法或代码块上加锁来实现线程的同步。Lock接口是Java并发包（JUC）中提供的一种更加灵活和可扩展的锁机制，相比synchronized关键字更加强大和可控。 在使用synchronized关键字时，可以使用两种方式进行锁定：对象锁和类锁。对象锁是通过对某个对象加锁来实现的，可以使用synchronized关键字修饰实例方法或代码块。类锁是通过对类加锁来实现的，可以使用synchronized关键字修饰静态方法或代码块。 当使用Lock接口时，需要使用Lock对象进行加锁和解锁操作。Lock接口提供了更加细粒度的锁定和解锁控制，可以实现更高级的同步需求。Lock接口的常用实现类有ReentrantLock和ReentrantReadWriteLock。 除了synchronized关键字和Lock接口，Java还提供了其他一些同步机制，如volatile关键字和Atomic包下的原子类。volatile关键字可以保证变量的可见性和禁止指令重排序，但不能保证原子性。而Atomic包下的原子类可以实现更高级的原子操作，如原子更新整型、原子更新引用等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值