7.线程系列- JUC中的LockSupport工具类

最新推荐文章于 2022-03-14 16:04:31 发布
最新推荐文章于 2022-03-14 16:04:31 发布
阅读量123 收藏
点赞数
分类专栏： thread 文章标签： 多线程
原文链接：https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ==&mid=2648933125&idx=1&sn=382528aeb341727bafb02bb784ff3d4f&chksm=88621b3bbf15922d93bfba11d700724f1e59ef8a74f44adb7e131a4c3d1465f0dc539297f7f3&scene=178&cur_album_id=1318984626890915841#rd
版权

本文主要内容

  1. 讲解3中让线程等待和唤醒的方法，每种方法配合具体的实例
  2. 介绍LockSupport主要用法
  3. 对比3中方式，了解他们之间的区别

LockSupport位于juc包下，算是juc中一个基础类，juc中很多地方都会使用LockSupport

关于线程等待、唤醒的方法，前面的文章中我们已经讲过2种了：

  1. 使用Object中的wait()，notify()方法让线程等待，唤醒
  2. 使用juc包中的Condition的await()，signal()方法唤醒线程

使用Object类中的方法实现线程等待和唤醒

实例1

public class Demo1 {

    static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");
            }
        });
        t1.setName("t1");
        t1.start();
        //休眠5秒
        TimeUnit.SECONDS.sleep(5);
        synchronized (lock) {
            lock.notify();
        }
    }
}

运行输出：

1563592938744,t1 start!
1563592943745,t1 被唤醒!

t1线程中调用lock.wait()方法让t1线程等待，主线程中休眠5秒之后，调用lock.notify()方法唤醒了t1线程，输出结果中，两行结果相差5秒左右，程序正常退出。

示例2

我们把上面代码中main方法内部改一下，删除了 synchronized关键字，看看有什么效果：

public class Demo2 {

    static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
            try {
                lock.wait();
            } catch (InterruptedException e) {
           	   e.printStackTrace();
            }
            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");
        });
        t1.setName("t1");
        t1.start();
        //休眠5秒
        TimeUnit.SECONDS.sleep(5);
        lock.notify();
    }
}

运行结果：

    Exception in thread "t1" java.lang.IllegalMonitorStateException
    1563593178811,t1 start!
        at java.lang.Object.wait(Native Method)
        at java.lang.Object.wait(Object.java:502)
        at com.itsoku.chat10.Demo2.lambda$main$0(Demo2.java:16)
        at java.lang.Thread.run(Thread.java:745)
    Exception in thread "main" java.lang.IllegalMonitorStateException
        at java.lang.Object.notify(Native Method)
        at com.itsoku.chat10.Demo2.main(Demo2.java:26)

上面代码中将synchronized去掉了，发现调用wait()方法和调用notify()方法都抛出了 IllegalMonitorStateException异常，原因：Object类中的wait、notify、notifyAll用于线程等待和唤醒的方法，都必须在同步代码中运行。

示例3

唤醒方法在等待方法之前执行，线程能够被唤醒么？代码如下：

public class Demo3 {

    static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lock) {
                System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
                try {
                    //休眠3秒
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");
            }
        });
        t1.setName("t1");
        t1.start();
        //休眠1秒之后唤醒lock对象上等待的线程
        TimeUnit.SECONDS.sleep(1);
        synchronized (lock) {
            lock.notify();
        }
        System.out.println("lock.notify()执行完毕");
    }
}

运行代码，输出结果：

    lock.notify()执行完毕
    1563593869797,t1 start!

输出了上面2行之后，程序一直无法结束，t1线程调用wait()方法之后无法被唤醒了，从输出中可见， notify()方法在 wait()方法之前执行了，等待的线程无法被唤醒了。说明：唤醒方法在等待方法之前执行，线程无法被唤醒。

关于Object类中的用户线程等待和唤醒的方法，总结一下：

  1. wait()/notify()/notifyAll()方法都必须放在同步代码中执行，需要先获取锁
  2. 线程唤醒的方法（notify、notifyAll）需要在等待的方法（wait）之后执行，等待中的线程才可能会被唤醒，否则无法唤醒

使用Condition实现线程的等待和唤醒

示例1

public class Demo4 {

    static ReentrantLock lock = new ReentrantLock();
    static Condition condition = lock.newCondition();

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {
            lock.lock();
            try {
                System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");
            } finally {
                lock.unlock();
            }
        });
        t1.setName("t1");
        t1.start();
        //休眠5秒
        TimeUnit.SECONDS.sleep(5);
        lock.lock();
        try {
            condition.signal();
        } finally {
            lock.unlock();
        }
    }
}

输出：

    1563594349632,t1 start!
    1563594354634,t1 被唤醒!

t1线程启动之后调用 condition.await()方法将线程处于等待中，主线程休眠5秒之后调用 condition.signal()方法将t1线程唤醒成功，输出结果中2个时间戳相差5秒。

示例2

我们将上面代码中的lock.lock()、lock.unlock()去掉，看看会发生什么。代码：

public class Demo5 {

    static ReentrantLock lock = new ReentrantLock();
    static Condition condition = lock.newCondition();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
            try {
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");
        });
        t1.setName("t1");
        t1.start();
        //休眠5秒
        TimeUnit.SECONDS.sleep(5);
        condition.signal();
    }
}

输出：

    Exception in thread "t1" java.lang.IllegalMonitorStateException
    1563594654865,t1 start!
        at java.util.concurrent.locks.ReentrantLock$Sync.tryRelease(ReentrantLock.java:151)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.release(AbstractQueuedSynchronizer.java:1261)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.fullyRelease(AbstractQueuedSynchronizer.java:1723)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2036)
        at com.itsoku.chat10.Demo5.lambda$main$0(Demo5.java:19)
        at java.lang.Thread.run(Thread.java:745)
    Exception in thread "main" java.lang.IllegalMonitorStateException
        at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.signal(AbstractQueuedSynchronizer.java:1939)
        at com.itsoku.chat10.Demo5.main(Demo5.java:29)

有异常发生， condition.await();和 condition.signal();都触发了 IllegalMonitorStateException异常。原因：调用condition中线程等待和唤醒的方法的前提是必须要先获取lock的锁。

示例3

唤醒代码在等待之前执行，线程能够被唤醒么？代码如下：

public class Demo6 {

    static ReentrantLock lock = new ReentrantLock();
    static Condition condition = lock.newCondition();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            lock.lock();
            try {
                System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");
            } finally {
                lock.unlock();
            }
        });
        t1.setName("t1");
        t1.start();
        //休眠5秒
        TimeUnit.SECONDS.sleep(1);
        lock.lock();
        try {
            condition.signal();
        } finally {
            lock.unlock();
        }
        System.out.println(System.currentTimeMillis() + ",condition.signal();执行完毕");
    }
}

运行结果：

    1563594886532,condition.signal();执行完毕
    1563594890532,t1 start!

输出上面2行之后，程序无法结束，代码结合输出可以看出signal()方法在await()方法之前执行的，最终t1线程无法被唤醒，导致程序无法结束。

关于Condition中方法使用总结：

  1. 使用Condtion中的线程等待和唤醒方法之前，需要先获取锁。否者会报 IllegalMonitorStateException异常
  2. signal()方法先于await()方法之前调用，线程无法被唤醒

Object和Condition的局限性

  1. 2中方式中的让线程等待和唤醒的方法能够执行的先决条件是：线程需要先获取锁
  2. 唤醒方法需要在等待方法之后调用，线程才能够被唤醒

LockSupport类介绍

LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程。主要是通过park()和unpark(thread)方法来实现阻塞和唤醒线程的操作

每个线程都有一个许可(permit)，permit只有两个值：0和1 ， 默认是0

  1. 当调用unpark(thread)方法，就会将thread线程的许可permit设置为1，注意多次调用unpark方法，不会累加，permit值还是1
  2. 当调用park()方法，如果当前线程的permi’t是1，那么将permit设置为0，并立即返回。如果当前的线程permit是0，那么当前线程就会阻塞，直到别的线程将当前线程的permit设置为1时，park方法会被唤醒，然后会见permit再次设置为0，并返回。

注意：因为permit默认是0，所以一开始调用park()方法，线程必定会被阻塞。调用unpark(thread)方法后，会自动唤醒thread线程，即park方法立即返回

LockSupport中常用的方法

阻塞线程

  • void park()：阻塞当前线程
  • void park(Object blocker)：功能同方法1，入参增加一个Object对象，用来记录导致线程阻塞的阻塞对象，方便进行问题排查
  • void parkNanos(long nanos)：阻塞当前线程，最长不超过nanos纳秒，增加了超时返回的特性
  • void parkUntil(long deadline)：阻塞当前线程，直到deadline，deadline是一个绝对时间，表示某个时间的毫秒格式
  • void parkUntil(Object blocker, long deadline)：功能同方法5，入参增加一个Object对象，用来记录导致线程阻塞的阻塞对象，方便进行问题排查；

唤醒线程

  • void unpark(Thread thread):唤醒处于阻塞状态的指定线程

示例1

主线程线程等待5秒之后，唤醒t1线程，代码如下：

public class ThreadDemo11 {

    public static class T1 extends Thread{
        @Override
        public void run() {
            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
            LockSupport.park();
            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        T1 t1 = new T1();
        t1.setName("t1");
        t1.start();
        //休眠5秒
        TimeUnit.SECONDS.sleep(5);
        LockSupport.unpark(t1);
        System.out.println(System.currentTimeMillis() + ",LockSupport.unpark();执行完毕");
    }
}

运行结果：

1604645111420,t1 start!
1604645116421,LockSupport.unpark();执行完毕
1604645116421,t1 被唤醒!

t1中调用 LockSupport.park();让当前线程t1等待，主线程休眠了5秒之后，调用 LockSupport.unpark(t1);将t1线程唤醒，输出结果中1、3行结果相差5秒左右，说明t1线程等待5秒之后，被唤醒了。

LockSupport.park();无参数，内部直接会让当前线程处于等待中；unpark方法传递了一个线程对象作为参数，表示将对应的线程唤醒。

示例2

唤醒方法放在等待方法之前执行，看一下线程是否能够被唤醒呢？代码如下：

public class ThreadDemo11 {

    public static class T1 extends Thread{
        @Override
        public void run() {
            try {
                TimeUnit.SECONDS.sleep(3);
                LockSupport.park();
                System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        T1 t1 = new T1();
        t1.setName("t1");
        t1.start();
        //休眠5秒
        LockSupport.unpark(t1);
        System.out.println(System.currentTimeMillis() + ",LockSupport.unpark();执行完毕");
    }
}

运行结果：

1604645337331,LockSupport.unpark();执行完毕
1604645340333,t1 被唤醒!

唤醒方法在等待方法之前执行，线程也能够被唤醒，这点是另外2中方法无法做到的。Object和Condition中的唤醒必须在等待之后调用，线程才能被唤醒。而LockSupport中，唤醒的方法不管是在等待之前还是在等待之后调用，线程都能够被唤醒。

示例3

park()让线程等待之后，是否能够响应线程中断？代码如下：

public class Demo9 {

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " start!");
            System.out.println(Thread.currentThread().getName() + ",park()之前中断标志：" + Thread.currentThread().isInterrupted());
            LockSupport.park();
            System.out.println(Thread.currentThread().getName() + ",park()之后中断标志：" + Thread.currentThread().isInterrupted());
            System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + " 被唤醒!");
        });
        t1.setName("t1");
        t1.start();
        //休眠5秒
        TimeUnit.SECONDS.sleep(5);
        t1.interrupt();
    }
}

输出：

    1563598536736,t1 start!
    t1,park()之前中断标志：false
    t1,park()之后中断标志：true
    1563598541736,t1 被唤醒!

t1线程中调用了park()方法让线程等待，主线程休眠了5秒之后，调用 t1.interrupt();给线程t1发送中断信号，然后线程t1从等待中被唤醒了，输出结果中的1、4行结果相差5秒左右，刚好是主线程休眠了5秒之后将t1唤醒了。结论：park方法可以相应线程中断。

LockSupport.park方法让线程等待之后，唤醒方式有2种：

  1. 调用LockSupport.unpark方法
  2. 调用等待线程的 interrupt()方法，给等待的线程发送中断信号，可以唤醒线程

示例4

LockSupport有几个阻塞放有一个blocker参数，这个参数什么意思，上一个实例代码，大家一看就懂了：

public class Demo10 {

    static class BlockerDemo {
    }
    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {
            LockSupport.park();
        });
        t1.setName("t1");
        t1.start();
        Thread t2 = new Thread(() -> {
            LockSupport.park(new BlockerDemo());
        });
        t2.setName("t2");
        t2.start();
    }
}

运行上面代码，然后用jstack查看一下线程的堆栈信息：

    "t2" #13 prio=5 os_prio=0 tid=0x00000000293ea800 nid=0x91e0 waiting on condition [0x0000000029c3f000]
       java.lang.Thread.State: WAITING (parking)
            at sun.misc.Unsafe.park(Native Method)
            - parking to wait for  <0x00000007180bfeb0> (a com.itsoku.chat10.Demo10$BlockerDemo)
            at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
            at com.itsoku.chat10.Demo10.lambda$main$1(Demo10.java:22)
            at com.itsoku.chat10.Demo10$$Lambda$2/824909230.run(Unknown Source)
            at java.lang.Thread.run(Thread.java:745)
    "t1" #12 prio=5 os_prio=0 tid=0x00000000293ea000 nid=0x9d4 waiting on condition [0x0000000029b3f000]
       java.lang.Thread.State: WAITING (parking)
            at sun.misc.Unsafe.park(Native Method)
            at java.util.concurrent.locks.LockSupport.park(LockSupport.java:304)
            at com.itsoku.chat10.Demo10.lambda$main$0(Demo10.java:16)
            at com.itsoku.chat10.Demo10$$Lambda$1/1389133897.run(Unknown Source)
            at java.lang.Thread.run(Thread.java:745)

代码中，线程t1和t2的不同点是，t2中调用park方法传入了一个BlockerDemo对象，从上面的线程堆栈信息中，发现t2线程的堆栈信息中多了一行 -parking to waitfor<0x00000007180bfeb0>(a com.itsoku.chat10.Demo10$BlockerDemo)，刚好是传入的BlockerDemo对象，park传入的这个参数可以让我们在线程堆栈信息中方便排查问题，其他暂无他用。

线程等待和唤醒的3种方式做个对比

在这里插入图片描述

那个少年~
关注
专栏目录
JUC学习 - LockSupport工具类
TyuIn的博客
11-25 491
一、JUC中的LockSupport工具类 LockSupport位于java.util.concurrent（简称juc）包中，算是juc中一个基础类，juc中很多地方都会使用LockSupport，非常重要！！！ 关于线程等待/唤醒的方法，前面的我们已经讲过2种了： 方式1：使用Object中的wait()方法让线程等待，使用Object中的notify()方法唤醒线程 方式2：使用juc包中Condition的await()方法让线程等待，使用signal()方法唤醒线程 Object和Condit
【JUC】Java并发编程从挖坑到入土全解（4-一文讲通LockSupport与线程中断-＞长图预警）
最新发布
aqin1012的博客
10-10 472
首先，一个线程不应该由其他线程强制中断或停止，而是应该由线程自己自行停止，自己来决定自己的命运（所以，Thread的stop()、suspend()、resume()都已经废弃了）其次，在Java中没有办法立即停止一条线程，然而停止线程又显得那么重要（比如需要取消一个耗时/错误操作）。因此，Java提供了一种用于停止线程的协商机制——中断，也即中断标识协商机制。中断只是一种协作协商机制，Java没有给中断增加任何语法，中断的过程完成完全要求程序员自己实现。
java学习系列-高并发13:JUC中的LockSupport工具类，必备技能
星之宇的博客
08-10 260
本文主要内容： 讲解3种让线程等待和唤醒的方法，每种方法配合具体的示例 介绍LockSupport主要用法 对比3种方式，了解他们之间的区别 LockSupport位于**java.util.concurrent（简称juc）**包中，算是juc中一个基础类，juc中很多地方都会使用LockSupport，非常重要，希望大家一定要掌握。 关于线程等待/唤醒的方法，前面的文章中我们已经讲过2种了： 方式1：使用Object中的wait()方法让线程等待，使用Object中的notify()方法唤醒线程
JUC锁之LockSupport
liuerchong的博客
06-18 1327
LockSupport是一个线程工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，也可以在任意位置唤醒。 它的内部其实两类主要的方法：park（停车阻塞线程）和unpark（启动唤醒线程）。
JUC---LockSupport
蓝天⊙白云的博客
06-07 264
1. LockSupport原理 LockSupport是一个编程工具类，主要是为了阻塞和唤醒线程用的。 LockSiupport的核心方法有两个，park和unpark，park用来阻塞当前调用线程，unpark用来唤醒指定线程。 LockSupport类使用了一种名为Permit（许可）的概念来做到阻塞和唤醒线程的功能，可以把许可看成是一种(0,1)信号量（Semaphore），但与 Semaphore 不同的是，许可的累加上限是1。 初始时，permit为0，当调用unpark()方法时，线程的per
12-JUC中的LockSupport工具类
永无止境
04-28 220
文章目录关于线程等待/唤醒的方法关于Object类中的用户线程等待和唤醒的方法关于Condition中方法使用总结：Object和Condition的局限性LockSupport类LockSupport中常用的方法总结参考 关于线程等待/唤醒的方法 方式1：使用Object中的wait()方法让线程等待，使用Object中的notify()方法唤醒线程 方式2：使用juc包中Condition的...
Java 多线程与并发(9-26)-JUC锁- LockSupport详解.pdf
07-23
LockSupport是Java中用于多线程同步的一个工具类，它提供了一组基础的线程阻塞和解除阻塞的方法。这个类位于java.util.concurrent.locks包下，是实现并发编程中AQS（AbstractQueuedSynchronizer）框架的重要基础之一...
Java 多线程与并发(7-26)-JUC - 类汇总和学习指南.pdf
07-22
Tools 类则提供了一些有用的工具类，例如 LockSupport 类，用于创建锁和其他同步类的基本线程阻塞原语。 2.Collections： Collections 部分提供了一些并发集合类，例如 CopyOnWriteArrayList、ConcurrentHashMap ...
【高并发】JUC中等待多线程完成的工具类CountDownLatch
九师兄
11-27 428
添加链接描述假如有这样一个需求，当我们需要解析一个Excel里多个sheet的数据时，可以考虑使用多线程，每个线程解析一个sheet里的数据，等到所有的sheet都解析完之后，程序需要统计解析总耗时。分析一下：解析每个sheet耗时可能不一样，总耗时就是最长耗时的那个操作。//休眠时间（秒） int sleepSeconds;System . out . println(startTime + "," + ct . getName() + ",开始处理!");try {
JUC 锁之 LockSupport 详解
liuwg1226的专栏
09-09 552
一 概述 今天我们来介绍 Java 并发编程系列之 LockSupport，在介绍 Synchronized 的时候我们有提过，不推荐同学们使用 Object 的 wait、notify、notifyAll 等函数做多线程间的通信协同，使用 LockSupport 会是更好的选择，本篇就来谈谈 LockSupport，也正好为下篇的 AQS（AbstractQueuedSynchronized）打基础。 二 LockSupport 概念 LockSupport 是线程工具类，主要作用是阻塞和唤醒线程，底层
[JUC] LockSupport浅析
zkp_java的专栏
02-12 380
这里写自定义目录标题wait/notifyLockSupportwait/notify和LockSupport对比LockSupport注意事项参考文献 LockSupport是Java6引入的一个工具类，它简单灵活，应用广泛。在没有LockSupport之前，线程的挂起和唤醒咱们都是通过Object的wait和notify/notifyAll方法实现。 我们以例子来说明两者之间的区别 wait/...
JUC-LockSupport（十七）
weixin_41979002的博客
03-14 175
一、LockSupport 是什么？ LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。 LockSupport中的park()和unpark()的作用分别是阻塞线程和解除阻塞线程，可以将其看作是线程等待唤醒机制(wait/notify)的加强版 二、传统两种线程等待唤醒的方法 方式1: 使用Object中的wait()方法让线程等待， 使用Object中的notify()方法唤醒线程，与synchronized配合使用。 方式2: 使用JUC包中Condition的await()方法让线
juc 之 LockSupport 锁工具
top_explore的博客
06-23 189
public static void main(String[] args) { final Thread thread = new Thread(() -> { System.out.println("阻塞"); LockSupport.park(); System.out.println("已解锁"); }); thread.start(); try { .
我学JUC之LockSupport
haoyifen的专栏
03-13 628
java.util.concurrent之LockSupport
JUC（LockSupport，AQS）
dafeng_xiaobai的博客
05-26 188
JUC第三季（LockSupport，AQS） 01_可重入锁（递归锁） 可重入锁又名递归锁，是指在同一个线程在外层方法获取锁的时候，再进入该线程的的内层方法会自动获取锁（前提是锁对象得是同一个对象），不会因为之前已经获取过还没释放而阻塞。 Java中ReentrantLock和synchronized都是可重入锁，可重入锁的一个优点是可一定程度避免死锁。 将字分开解释： 可：可以 重：再次 入：进入 锁：同步锁 进入什么？ - 进入同步域（即同步代码块/方法或显示锁锁定的代码） 一个线
JUC___LockSupport类
define_us的专栏
12-06 169
LockSupport是对Unsafe的一些封装。下面对一些常见方法进行解释。主要提供线程的park和unpark方法。 /** * Disables the current thread for thread scheduling purposes unless the * permit is available. * * &lt;p&gt;If ...
JUC(五)锁机制之LockSupport工具和Condition接口
程序员XW
07-24 350
AQS的内部结构，与其独占式与共享式获取同步状态的实现。但是并没有详细描述线程是如何进行阻塞与唤醒的。我也提到了线程的这些操作都与LockSupport工具类有关。现在我们就一起来探讨一下该类的具体实现。 LockSupport类 了解线程的阻塞和唤醒，我们需要查看LockSupport类。具体代码如下： public class LockSupport { private Loc...
JUC锁：LockSupport详解
weixin_42215488的博客
09-14 142
JUC锁：LockSupport详解 特点 与Object 的 wait & notify 相比 wait，notify 和 notifyAll必须配合Object Monitor（synchronized） 一起使用，park，unpark 不必。 park & unpark 是以线程为单位来【阻塞】和【唤醒】线程，而notify 只能随机唤醒一个等待线程，notifyAll是唤醒所有等待线程 park & unpark可以先unpark 而wait& notify 不
java juc LockSupport详解
qq_37385585的博客
02-02 191
LockSupport是什么 用来创建锁和其他同步类的基本线程阻塞原语 LockSupport就是线程等待唤醒机制 wait/notify 的改良加强版 那么问题来了，为什么要加强等待唤醒机制，原来使用的等待唤醒机制有什么缺点 使用synchornized和Lock的等待唤醒机制 1. 使用Object中的 wait() 方法让线程等待，使用Object中的notify() 方法唤醒线程 问题1.使用wait和notify的时候 必须包裹在synchronized关键字中 使用wait和notify的时候，
Java并发编程：掌握JUC并发工具类
这个包包含了一系列的并发工具类，旨在简化多线程环境下的编程，提供更加高效和安全的线程交互机制。 2、CountDownLatch闭锁 CountDownLatch是一种计数器式的同步辅助类，它允许一个或多个线程等待其他线程完成操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值