22_LockSupport

最新推荐文章于 2024-07-24 03:47:28 发布
最新推荐文章于 2024-07-24 03:47:28 发布
阅读量387 收藏 5
点赞数 1
分类专栏： # 并发 文章标签： LockSupport
By_Code27
本文链接：https://blog.csdn.net/XJ0927/article/details/113139643
版权

是什么

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

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

怎么玩

线程等待唤醒机制(wait/notify)

3种让线程等待和唤醒的方法
方式1: 使用synchronized

使用Object中的wait()方法让线程等待， 使用Object中的notify()方法唤醒线程

正常情况：

package com.aqs.locksupport;

/**
 * @Author: xj0927
 * @Description:
 * @Date Created in 2021-01-25 11:33
 * @Modified By:
 */
public class SynchronizedDemo {

    static Object objectLock = new Object();

    private static void synchronizedWaitNotify() {
        new Thread(() -> {
            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" + "------被唤醒");
            }
        }, "A").start();
        new Thread(() -> {
            synchronized (objectLock) {
                objectLock.notify();
                System.out.println(Thread.currentThread().getName() + "\t" + "------通知");
            }
        }, "B").start();
    }

    public static void main(String[] args) {
        SynchronizedDemo.synchronizedWaitNotify();
    }
}

在这里插入图片描述

异常情况1：wait方法和notify方法，两个都去掉同步代码块

package com.aqs.locksupport;

/**
 * @Author: xj0927
 * @Description:
 * @Date Created in 2021-01-25 11:33
 * @Modified By:
 */
public class SynchronizedDemo {

    static Object objectLock = new Object();

    private static void synchronizedWaitNotify() {
        new Thread(() -> {
//            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" + "------被唤醒");
//            }
        }, "A").start();
        new Thread(() -> {
//            synchronized (objectLock) {
                objectLock.notify();
                System.out.println(Thread.currentThread().getName() + "\t" + "------通知");
//            }
        }, "B").start();
    }

    public static void main(String[] args) {
        SynchronizedDemo.synchronizedWaitNotify();
    }
}

在这里插入图片描述

抛出异常！

原因：synchronized是关键字属于JVM层面。monitorenter(底层是通过monitor对象来完成,其实wait/notify等方法也依赖monitor对象只能在同步块或方法中才能调用wait/notify等方法)

异常情况2：将notify放在wait方法前面

package com.aqs.locksupport;

import java.util.concurrent.TimeUnit;

/**
 * @Author: xj0927
 * @Description:
 * @Date Created in 2021-01-25 11:33
 * @Modified By:
 */
public class SynchronizedDemo {
    static Object objectLock = new Object();

    public static void main(String[] args) {

        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } 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" + "------被唤醒");
            }
        }, "A").start();
        new Thread(() -> {
            synchronized (objectLock) {
                objectLock.notify();
                System.out.println(Thread.currentThread().getName() + "\t" + "------通知");
            }
        }, "B").start();
    }
}

在这里插入图片描述

B线程先notify后，A线程后使用wait会出现另一个线程一直处于等待状态

小总结

  • wait和notify方法必须要在同步块或者方法里面且成对出现使用
  • 先wait后notify才OK
方式2：使用 lock

Condition接口中的await后signal方法实现线程的等待和唤醒

正常情况：

package com.aqs.locksupport;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @Author: xj0927
 * @Description:
 * @Date Created in 2021-01-25 11:56
 * @Modified By:
 */
public class ReentrantLockDemo {

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

    public static void main(String[] args) {
        new Thread(() -> {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "\t" + "------come in");
                try {
                    //等待
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "\t" + "------被唤醒");
            } finally {
                lock.unlock();
            }
        }, "A").start();

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

在这里插入图片描述

异常情况1：不进行lock加锁、放锁

package com.aqs.locksupport;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @Author: xj0927
 * @Description:
 * @Date Created in 2021-01-25 11:56
 * @Modified By:
 */
public class ReentrantLockDemo {

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

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

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

}

在这里插入图片描述

同样也抛出异常！

异常情况2：先unlock释放锁，再lock加锁

package com.aqs.locksupport;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @Author: xj0927
 * @Description:
 * @Date Created in 2021-01-25 11:56
 * @Modified By:
 */
public class ReentrantLockDemo {

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

    public static void main(String[] args) {

        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + "\t" + "------come in");
                try {
                    //TODO 一直卡在这里等待被唤醒
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "\t" + "------被唤醒");
            } finally {
                lock.unlock();
            }
        }, "A").start();

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

在这里插入图片描述

B线程先进行释放锁，A线程再加锁，线程一直处于等待状态！

总结

传统的synchronized和Lock实现等待唤醒通知的约束

必须满足下列条件：

  • 线程先要获得并持有锁，必须在锁块（synchronized或lock）中
  • 必须要先等待后唤醒，线程才能够被唤醒
方式3：使用LockSupport

LockSupport类中的park等待和unpark唤醒

是什么

通过park()和unpark(thread)方法来实现阻塞和唤醒线程的操作

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

LockSupport类使用了一种名为Permit(许可）的概念来做到阻塞和唤醒线程的功能，每个线程都有一个许可(permit),permit只有两个值1和零，默认是零。可以把许可看成是一种(0,1)信号量(Semaphore），但与Semaphore不同的是，许可的累加上限是1。

主要方法

阻塞：park()/park(Object blocker)：阻塞当前线程/阻塞传入的具体线程

permit默认是0，所以一开始调用park()方法，当前线程就会阻塞，直到别的线程将当前线程的permit设置为1时,park方法会被唤醒，然后会将permit再次设置为0并返回。

唤醒：unpark(Thread thread)：唤醒处于阻断状态的指定线程

调用unpark(thread)方法后，就会将thread线程的许可permit设置成1(注意多次调用unpark方法，不会累加，permit值还是1)会自动唤醒thread线程，即之前阻塞中的LockSupport.park()方法会立即返回。

代码

正常情况：无锁块要求

package com.aqs.locksupport;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

/**
 * LockSupport：俗称 锁中断
 * 以前的两种方式：
 * 		1.以前的等待唤醒通知机制必须synchronized里面有一个wait和notify
 * 		2.lock里面有await和signal
 * 这上面这两个都必须要持有锁才能干
 * LockSupport它的解决的痛点
 * 		1.LockSupport不用持有锁块，不用加锁，程序性能好，
 * 		2.先后顺序，不容易导致卡死
 */
public class LockSupportDemo {
    public static void main(String[] args) {

        Thread t1 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t ----" + "come  in....");
            LockSupport.park();//阻塞当前线程...等待被放行
            System.out.println(Thread.currentThread().getName() + "\t ----被唤醒");
        }, "t1");

        t1.start();

        //等待3s，让t2线程发放许可证
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t ----" + "通知了");
            LockSupport.unpark(t1);

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

在这里插入图片描述

之前错误的先唤醒后等待，LockSupport照样支持：

public class LockSupportDemo {
    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();

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t ----" + "通知了");
            LockSupport.unpark(t1);

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

在这里插入图片描述

发现t1线程并没有进入执行lock方法（此时它已有许可证）

底层原理

LockSupport是用来创建锁和其他同步类的基本线程阻塞原语，LockSupport是一个线程阻塞工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，阻塞之后也有对应的唤醒方法。归根结底，LockSupport调用的Unsafe中的native代码。

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

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

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

  • LockSupport和每个使用它的线程都有一个许可(permit)关联。permit相当于1，0的开关，默认是0。
  • 调用一次unpark就加1变成1，调用一次park会消费permit，也就是将1变成0，同时park立即返回。
  • 如再次调用park会变成阻塞(因为permit为零了会阻塞在这里，一直到permit变为1)，这时调用unpark会把permit置为1。
  • 每个线程都有一个相关的permit, permit最多只有一个，重复调用unpark也不会积累凭证。

形象的理解：

  • 线程阻塞需要消耗凭证(permit)，这个凭证最多只有1个。
  • 当调用park方法时 ，如果有凭证，则会直接消耗掉这个凭证然后正常退出; 如果无凭证，就必须阻塞等待凭证可用;
  • 而unpark则相反，它会增加一个凭证，但凭证最多只能有1个，累加无效。
public class LockSupportDemo {
    public static void main(String[] args) {

        Thread t1 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t ----" + "come  in....");
            //消耗一张凭证
            LockSupport.park();
            //TODO 没有凭证,继续等待.....
            LockSupport.park();
            System.out.println(Thread.currentThread().getName() + "\t ----被唤醒");
        }, "t1");

        t1.start();

       try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t ----" + "通知了");
            //TODO 发放凭证：最多为1
            LockSupport.unpark(t1);
            LockSupport.unpark(t1);
            
        }, "t2").start();
    }
}

在这里插入图片描述

此时虽然unpark了两次，但是permit许可证最多为1，所以第一次park消费掉凭证，第二次park时，许可证为0，阻塞等待。

# 面试题
# 为什么可以先唤醒线程后阻塞线程?
因为unpark获得了一个凭证，之后再调用park方法，就可以名正言顺的凭证消费，故不会阻塞。

# 为什么唤醒两次后阻塞两次，但最终结果还会阻塞线程?
因为凭证的数量最多为1，连续调用两次unpark和调用一次unpark效果一样，只会增加一个凭证;而调用两次park却需要消费两个凭证，证不够，不能放行。
多线程工具类：CountDownLatch、CyclicBarrier、Semaphore、LockSupport
Java学习录
03-31 357
◆ CountDownLatch ◆ 假如有一个任务想要往下执行，但必须要等到其他的任务执行完毕后才可以。 比如你想要买套房子，但是呢你现在手上没有钱。你得等这个月工资发了、然后年终奖发了、然后朋友借你得钱还给你了、然后再给朋友借一部分才可以买，这种场景你就可以使用CountDownLatch。 CountDownLatch是JDK为我们提供的一个计数器，它的操作是原子操作，同一时间只能有一个...
Java开发常见面试题详解（LockSupport，AQS，Spring循环依赖，Redis）
热门推荐
KISS
03-28 3万+
00_前言闲聊和课程说明 教学视频 暖身面试题 Redis默认端口是多少？- 6379 link Spring官网地址 - https://spring.io 经典计算机图书看过吗？ 01_字符串常量Java内部加载-上 Returns a canonical representation for the string object. A pool of strings, initially empty, is maintained privately by the class String. Whe
LockSupport分析
lwgzj的博客
04-26 439
前几篇分析过wait和notify方法，这两个方法是用来在两个线程之间进行通信的（生产者消费者模型的基本实现）。a.wait()-> b.execute()->b.notify()->a.execute()。我们要知道，在实现两个线程之间能够切换运行时，wait和notify方法其实是运用了一个中间变量，就是Object对象来实现的。今天我们要学习的LockSupport则不是这...
LockSupport
zhouhe_的博客
05-25 164
AQSLockSupportLockSupport是什么线程等待唤醒机制（wait/notify）三种让线程等待和唤醒的方法Object类中的wait和notify方法实现线程等待和唤醒代码Condition接口中的await和signal方法实现线程的等待和唤醒传统的synchronized和lock实现等待唤醒通知的约束LockSupport类中的park等待和唤醒是什么方法demo重要说明 LockSupport LockSupport是什么 java.util.concurrent.locks下的一
LockSupport详解
最新发布
weixin_33427476的博客
07-24 37
目录LockSupport详解1、LockSupport简介LockSupport 类的构造方法LockSupport 类的属性`Thread`类的`parkBlocker`属性LockSupport 类的常用方法挂起线程的相关方法唤醒线程的相关方法`unpark(Thread thread)`方法注意点LockSupp...
【线程、锁】LockSupport示例
m0_45406092的博客
01-30 182
文章目录1. LockSupport的作用2. 演示 1. LockSupport的作用 LockSupport.park() 让当前线程阻塞 LockSupport.unpark(t0) 唤醒to线程，需指定被唤醒的线程 2. 演示 我们创建一个t0线程，该线程内部的run()方法体内实现一个循环打印，但是每次循环时，会调用LockSupport阻塞当前的t0线程，主线程会唤醒一次t0，然后下次循环时会再次陷入循环，这次，就没人再去唤醒t0了，只好永远阻塞下去： package com.test;
LockSupport源码解析
m47838704的专栏
03-26 677
绪 今天和朋友讨论Java中的锁机制的时候，谈论到了LockSupport类，在之前一直没有使用过该类，所以当提到该类的时候还是有点陌生，然后看了一下JDK的源码和该类相关的技术博客，整理了一下该类的原理和使用场景。 使用 package mthread; import org.junit.Test; import java.util.concurrent.TimeUnit; i...
LockSupport类
清新哥哥的博客
08-29 2444
LockSupport LockSupport看名字叫锁支持，这个玩意的功能跟wait和notify很像，它也是可以阻塞一个线程，然后又可以恢复一个线程，不过有个比较大的区别就是，wait让线程阻塞前，必获取到同步锁。而LockSupport这个哥们比较牛逼，随时随地随便阻塞当前线程，你给它一个线程它就敢让那个线程阻塞。 它是通过park()方法阻塞当前线程的...
Java多线程Day22-JUC锁之LockSupport
攻城狮Chova的博客
05-13 300
LockSupport
LockSupport理解
weixin_30851409的博客
01-24 87
一、背景 在看并发包源码的时候看见过LockSupport,今天恰巧看到LockSupport字眼,于是看下jdk1.7中的源码结构。想着它应该是运用多线程的锁工具的，到底似乎怎么实现的呢？ 二、使用 于是自己写个demo对比下synchronized 场景：main线程中创建一个线程A,想让threadA 循环完毕的时候先阻塞，然后再main线程中释放。 1.控制多线程并发： ...
Java LockSupport学习
杀神lwz的博客
02-17 754
java.util.concurrent.locks下的类LockSupport：用于创建锁和其他同步类的基本线程阻塞原语。park():阻塞线程unpark():解除阻塞线程LockSupport：是线程等待唤醒机制(wait/notify)的加强版让线程等待和唤醒的方法：方式1：使用Object中的wait()方法让线程等待，使用Object中的notify()方法唤醒线程方式2：使用JUC包中Condition的await()方法让线程等待，使用signal()方法唤醒线程。
JUC在深入面试题——三种方式实现线程等待和唤醒（wait/notify，await/signal，LockSupport的park/unpark）
虚幻私塾
09-23 270
在多线程的场景下，我们会经常使用加锁，来保证线程安全。如果锁用的不好，就会陷入死锁，我们以前可以使用Object的来解决死锁问题。也可以使用Condition的来解决，当然最优还是的。他们都是解决线程等待和唤醒的。下面来说说具体的优缺点和例子证明一下。wait和notify方法必须要在同步块或者方法里面且成对出现使用，否则会抛出。调用顺序要先wait后notify才可以正常阻塞和唤醒。await和signal方法必须要在同步块或者方法里面且成对出现使用，否则会抛出。
java线程阻塞的原因_记一次锁使用不当导致Dubbo线程阻塞问题
weixin_29050513的博客
02-26 1081
背景线上环境一个后台项目，提供基于dubbo实现的事件分发服务，最近突然出现心跳超时。问题分析检查内存是否溢出jstat -gcutil 8166 1000意料之中，内存正常，因为内部有接入内存溢出告警，如果是内存溢出应该有收到通知，但是这次没有溢出通知。查看线程栈jstack -l 8166发现有大量DubboServerHandler开头的线程阻塞在一个同样的地方，脱敏简化后信息如下："Dub...
java排查cpu消耗多_一次java Cpu占用过高的排查
weixin_31655087的博客
03-02 558
"dubbo-remoting-client-heartbeat-thread-1" #46 daemon prio=5 os_prio=0 tid=0x000000005c53e000 nid=0x240c waiting on condition [0x000000006447f000]java.lang.Thread.State: WAITING (parking)at sun.misc.U...
23_AQS源码分析
多回头看一看
01-25 2364
前置知识: 公平锁和非公平锁 可重入锁 LockSupport 自旋锁 数据结构之链表 设计模式之模板设计模式 是什么 字面意思：抽象的队列同步器 源代码：AbstractQueuedSynchronizer 简称为AQS 技术翻译：是用来构建锁或者其它同步器组件的重量级基础框架及整个JUC体系的基石，通过内置的FIFO队列来完成资源获取线程的排队工作，并通过一个int类变量表示持有锁的状态。 这里的同步器组件指CountDownLatch、Semaphore、ReentrantLock、Re
1_谈谈Volatile
多回头看一看
11-11 658
????来源 Bilibili 尚硅谷周阳老师学习视频：尚硅谷Java大厂面试题第二季 1_Volatile 和 JMM 内存模型的可见性 JUC（java.util.concurrent） 进程和线程 进程：后台运行的程序（我们打开的一个软件，就是进程） 线程：轻量级的进程，并且一个进程包含多个线程（同在一个软件内，同时运行窗口，就是线程） 并发和并行 并发：同时访问某个东西，就是并发 并行：一起做某些事情，就是并行 JUC 下的三个包 java.util.concurrent
3_谈谈原子类的ABA问题
多回头看一看
11-12 467
原子类 AtomicInteger 的ABA问题 连环套路 从 AtomicInteger 引出下面的问题： CAS -> Unsafe -> CAS 底层思想 -> ABA -> 原子引用更新 -> 如何规避 ABA 问题 ABA 问题是什么 假设现在有两个线程，分别是 T1 和 T2，然后 T1 执行某个操作的时间为10 秒，T2 执行某个时间的操作是 2 秒，最开始 AB 两个线程，分别从主内存中获取 A 值，但是因为 B 的执行速度更快，他先把A的值改成B，然后在修改
10_线程池
多回头看一看
11-14 408
前言 获取多线程的方法，我们都知道有三种，还有一种是实现 Callable 接口 实现 Runnable 接口 实现 Callable 接口 实例化 Thread 类 使用 线程池 获取 Callable 接口 Callable 接口，是一种让线程执行完成后，[ 能够返回结果的 ] 在说到 Callable 接口的时候，我们不得不提到 Runnable 接口 [ 两种写法 ] /** * 实现Runnable接口 */ class MyThread implements Runnable {
thread.sleep会释放锁吗_面试 LockSupport.park()会释放锁资源吗？
05-26
而 `LockSupport.park()` 方法也不会释放锁资源，它只是阻塞当前线程，直到接收到某个信号（如中断信号）或者超时。当线程因为调用 `LockSupport.park()` 方法而被阻塞时，如果其他线程试图获取该线程持有的锁，那么...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值