Java 多线程-1

已于 2024-07-07 18:49:43 修改
阅读量710 收藏 17
点赞数 14
文章标签： spring boot 学习 后端
于 2024-06-23 19:13:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45149567/article/details/139904654
版权

一. LockSupport

LockSupport 我们可以把它当成工具类来使用；

  • park()：阻塞挂起当前线程；
  • unpark(Thread thread)：恢复某个线程的运行；

值得一提的是，LockSupport 的 park() 不会抛出任何异常；

1. 常规使用

常规使用如下：

public class TestLockSupport {

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("锁住当前线程t1");
                LockSupport.park();
                System.out.println("解锁了当前线程t1");
            }
        });

        t1.start();
        Thread.sleep(4000);

        System.out.println("主线程解锁t1线程");
        LockSupport.unpark(t1);
        System.out.println(t1.isInterrupted());
    }
}

打印如下：

锁住当前线程t1
主线程解锁t1线程
false
解锁了当前线程t1

2. park()

park() 可以被 LockSupport.unpark() 和 thread.interrupt() 打断；

2.1 LockSupport.unpark()

  • 如果线程已经处于 park() 状态，即已经被阻塞，那么此时调用 unpark() 会使该线程解除阻塞状态；

  • 如果线程尚未被阻塞，再次调用 unpark() 不会影响线程的执行状态，会确保线程下一次调用 park() 时立即返回，线程不会被阻塞；

多次调用 LockSupport.unpark() 有用吗？

LockSupport 的 park() 和 unpark() 是基于一个类似二元信号量的机制，即只有一个许可证可供使用，这个许可证是不可累积的，意味着无论 unpark() 被调用多少次，都只会释放一个许可证；

如果在一个线程尚未调用 park() 之前，多次调用 unpark()，那么只有第一次调用会实际产生效果，为后续可能的 park() 调用提供一个许可证，后续的 unpark() 调用在该线程下一次 park() 之前是没有实际作用的，因为它们不会累积许可证；

2.2 thread.interrupt()

  • 对于被 park() 阻塞住的线程 thread，如果执行 thread.interrupt()，线程会被中断，线程中断标识位 thread.isInterrupt() == true，线程恢复运行；
  • 可以理解为 LockSupport.unpark() 的效果和 thread.interrupt() 差不多，都会使线程 thread 重新运行，区别在于后者会将线程中断标识位 thread.isInterrupt() 置为 true；

示例如下：

public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("锁住当前线程t1");
                LockSupport.park();
                System.out.println("解锁了当前线程t1");
            }
        });

        t1.start();
        Thread.sleep(4000);

        System.out.println("主线程解锁t1线程");
        t1.interrupt();
        System.out.println(t1.isInterrupted());
    }

打印如下，可以看到的是，对于被 park() 阻塞住的线程，如果执行 thread.interrupt() 唤醒 thread 线程时，不会抛出异常；

锁住当前线程t1
主线程解锁t1线程
true
解锁了当前线程t1

二. Thread.sleep()

Thread.sleep() 是我们经常使用到的方法，但我们对这个方法的理解可能还不够，主要是因为 Thread.interrupt() 的存在；

1. 简单使用

主要使用如下，我们一般忽略 Thread.sleep() 抛出的 InterruptedException 异常；

public static void main(String[] args) {
    try {
        Thread.sleep(5000);
    } catch (InterruptedException e) {
        System.out.println("当前线程被中断了");
        e.printStackTrace();
    }
    System.out.println("主线程执行完成");
}

打印如下：

主线程执行完成

2. 执行thread.interrupt()

如果我们想打断正在 sleep() 的线程 t1，可以执行 t1.interrupt()；

需要注意的是：

  • 对于 LockSupport.park() 阻塞住的线程，执行 t1.interrupt() 会中断线程，t1 线程会恢复运行，t1.isInterrupted() == true；
  • 对于 t1.sleep() 阻塞住的线程，执行 t1.interrupt() 会中断线程，t1.sleep() 会抛出 InterruptedException 异常，但是线程的中断标志位会重置为 false，t1.isInterrupted() == false；这里比较绕；

我们看一个 Thread.sleep() 被 interrupt() 中断的例子；

public class TestSleep02 {
    
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            try {
                System.out.println("thread working");
                Thread.sleep(5000);
                System.out.println("thread working over");  // 该行不会被执行
            } catch (InterruptedException e) {
                System.out.println("occur interruptException");
                // 当 sleep() 被中断时，会抛出InterruptedException
                System.out.println(Thread.currentThread().isInterrupted());  // false
                // 通常我们也会在这里重新设置中断状态，以便上层代码知道发生了中断
                // Thread.currentThread().interrupt();
            }
        });

        thread.start();

        Thread.sleep(3000);
        System.out.println("开始打断 thread 线程");
        thread.interrupt();
    }
}

打印如下：

thread working
开始打断 thread 线程
occur interruptException
false

三. Thread.interrupt()

通过上面 LockSupport 和 Thread.sleep() 的学习，其实我们对 Thread.interrupt() 已经有了一定的了解，下面我们介绍一下 Thread.interrupt() 和线程的中断标志位；

  1. interrupt() 会将线程的中断标志位 interrupt 置为 true，默认值是 false；

    • 如果线程 t1 处于阻塞状态（即调用了sleep()、wait()、join()），当调用 t1.interrupt() 时会抛出中断异常InterruptedException，并且中断标记立即清除重置为 false；
    • 如果线程 t1 是被 park() 阻塞挂起，当调用 t1.interrupt() 会打断 t1 线程，t1 线程恢复运行，t1 线程的中断标志位为 true，不会被清除重置；

  2. isInterrupted() 会返回该线程的 interrupt 中断状态；

  3. interrupted() 是测试当前线程是否处于中断状态，是的话返回 true，并且调用完毕后立即将该中断标记清除重置为 false；线程不是中断状态的话，直接返回 false；

需要注意一点，对于正常运行的线程来说，interrupt() 的作用只是将中断标志位置为 true，它并不是真正的中断线程；

1. interrupted()

对于 thread.interrupted()，它的作用是：测试当前线程是否处于中断状态，是的话返回 true，并且调用完毕后立即将该中断标记清除重置为 false；线程不是中断状态的话，直接返回 false；

我们举个例子：

public class TestInterrupt {

    public static void main(String[] args) {
        System.out.println("主线程开始");
        Thread.currentThread().interrupt();
        System.out.println("主线程是否处于中断状态："+Thread.interrupted());    //true
        System.out.println("主线程是否处于中断状态："+Thread.interrupted());    //false
        System.out.println("主线程是否处于中断状态："+Thread.interrupted());    //false
        System.out.println("主线程结束");
    }
}

打印如下：

主线程开始
主线程是否处于中断状态：true
主线程是否处于中断状态：false
主线程是否处于中断状态：false
主线程结束

四. Monitor

monitor 是通过 C 来实现的，每个 Java 对象都有它关联的 Monitor 对象，结构如下：

ObjectMonitor() {
    _count        = 0;     // 用来记录该对象被线程获取锁的次数
    _waiters      = 0;
    _recursions   = 0;     // 锁的重入次数
    _owner        = NULL;  // 指向持有 ObjectMonitor 对象的线程 
    _WaitSet      = NULL;  // 处于 wait 状态的线程，会被加入到 _WaitSet
    _WaitSetLock  = 0 ;
    _EntryList    = NULL ; // 处于等待锁 block 状态的线程，会被加入到该列表
}
  1. 首先，所有并发获取锁的线程会被放入 EntryList 里；
  2. 当一个线程获取到对象 A 的锁时，将 A 对象关联的 monitor 对象里的 owner 指向当前线程，将 monitor 里的 count 加1；
  3. 这时如果对象 A 调用 wait()，则将 monitor 中 count 减 1，将 owner 置为 null；并将该线程放入 waitSet 里，等待唤醒；

获取 Monitor 过程如下图所示：

  • 刚开始 Monitor 中 Owner 为 null；

  • 当 Thread-2 执行 synchronized(obj) 就会将 Monitor 的所有者 Owner 置为 Thread-2，Monitor 中只能有一个 Owner；

  • 在 Thread-2 上锁的过程中，如果 Thread-3，Thread-4，Thread-5 也来执行 synchronized(obj)，就会进入 EntryList BLOCKED；

  • Thread-2 执行完同步代码块的内容，会释放锁，唤醒 EntryList 中等待的线程来竞争锁；

  • WaitSet 中的 Thread-0，Thread-1 是之前获得过锁，但条件不满足执行了 this.wait()，进入 WAITING 状态的线程；这些线程只有当被 notify() 时才会重新进入到 EntryList BLOCKED 竞争获取锁，获取锁成功的话从 wait() 处开始执行；

在这里插入图片描述

1. wait()和notify()

我们看下 Object.wait()、Object.notify()、Object.notifyAll() 的作用：

  • Object.wait()：当线程调用 wait() 时，它会释放对象的锁，并且放弃CPU，将自己置于该对象的等待队列中，等待被唤醒。
  • Object.notify()：当另一个线程拥有该对象的锁并调用 notify() 时，它会从等待队列中随机选择一个线程并唤醒它，使其有机会重新获取锁并继续执行；一旦 notify() 被调用，等待队列中的其他线程仍然处于等待状态，除非再次调用 notify() 或 notifyAll()。
  • Object.notifyAll()：与 notify() 不同，notifyAll() 会唤醒所有在该对象上等待的线程；一旦被唤醒，这些线程将竞争对象的锁，成功获取锁的线程将继续执行，而未获取锁的线程可能再次进入等待状态，直到锁被释放；

值得注意的是，wait()、notify() 和 notifyAll() 都必须在 synchronized 代码块或方法中调用，且调用的对象必须是synchronized 块或方法的锁对象。否则，将抛出 IllegalMonitorStateException 异常，因为这些方法的语义依赖于线程已经持有了对象的锁；

等待和阻塞不是一个概念，等待的线程是之前已经获取过锁的线程，当线程被唤醒后重新获取到锁时会从 obj.wait() 处运行代码；阻塞的线程是当前对象 obj 已经被其他线程持有了锁，于是只能阻塞挂起，直到锁被释放之后才会去争抢锁；

2. wait()和sleep()的区别

  1. sleep() 是 Thread 的静态方法，wait() 是 Object 的 方法；
  2. sleep() 可以在任意地方使用，wait() 和 notify() 只能在 synchronized 同步代码块中使用；
  3. sleep() 线程不会释放锁，它也不需要占有锁，wait() 线程会释放锁；
买断
关注
  • 14
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java多线程-线程间的通信
02-02
Java多线程--线程间的通信
Java多线程-Socket编程
01-27
Java 多线程-Socket 编程 Java 多线程-Socket 编程是指在 Java 语言中使用多线程技术来实现网络编程，特别是使用 Socket 编程来实现客户端和服务器端的通信。在 Java 中，多线程可以使用 Thread 类和 Runnable 接口...
Java多线程-多功能演示系统.zip
02-02
Java多线程-多功能演示系统，连接MySQL数据库利用多线程实现信息交流，为教师提供教学服务，便于教师整理教学资料，整合所需知识内容，更好的为学生提供生动形象的理解方式，加强教师与学生之间的互动沟通。
java多线程-新.xmind
03-02
一个自己整理的多线程相关知识梳理思维导图，里面若有不正确的还望指出
后端之路——最规范、便捷的spring boot工程配置
m0_73991249的博客
07-05 925
上一篇我们学了阿里云OSS的使用，那么我们为了方便使用OSS来上传文件，就创建了一个【util】类，里面有一个【AliOSSUtils】类，虽然本人觉得没啥不方便的，但是黑马视频又说这样还是存在不便维护和管理问题，我一时也还是想不明白但是想了一下确实，因为我们只是学了简单文件的OSS上传，但其实还有很多复杂的比如：那么我们肯定要对应不同的上传，再生成对应很多的阿里云OSS上传的【工具类】，那么每一个类里都得配置一遍基本配置信息，那么加入有一天这个accessKey被我禁用了，或者换了一个bucketName
idea创建spring boot项目，java版本只能选择17和21
weixin_63680330的博客
07-05 250
修改Server URL为https://start.aliyun.com。创建spring boot没有java对应11的可选。目前阿里云还是支持创建Spring2.X版本的项目的。
Spring Boot集成olingo快速入门demo
HBLOG
07-06 389
Apache Olingo 是个 Java 库，用来实现 Open Data Protocol (OData)。Apache Olingo 包括服务客户端和 OData 服务器方面。
Spring Boot与Traefik的集成
微赚淘客开发者博客
07-06 459
在当今的微服务架构中，服务的动态管理和路由是至关重要的。通过本文的介绍，我们了解了如何在Spring Boot应用中集成Traefik，实现动态的服务路由和负载均衡。在Spring Boot应用的Docker Compose或者Docker Swarm服务配置中，添加Traefik需要的标签，以便Traefik可以自动发现和路由服务。利用Traefik的动态配置能力，结合Spring Cloud配置中心（如Spring Cloud Config）或者环境变量，实现灵活的服务路由和配置管理。
【Spring Boot】Spring AOP中的环绕通知
smile_sundays的博客
07-02 2578
Aspect Oriented Programming（面向切面编程）AOP是Spring框架的第⼆⼤核⼼(第⼀⼤核⼼是IoC)AOP是一种思想，是对某一类事情的集中处理。其中在下面的学习中我们会学习到拦截器、统一异常处理，统一结果处理等，这些都是运用了AOP的统一思想来实现的。
使用Spring Boot和HBase实现大数据存储
微赚淘客开发者博客
07-06 509
HBase作为Apache Hadoop生态系统中的一个关键组件，提供了高可靠性、高性能的非关系型分布式数据库解决方案，适用于需要快速随机访问大数据集的场景。通过本文的介绍，我们了解了如何在Spring Boot应用中集成和使用HBase，实现了大数据存储和高效访问的功能。大家好，我是免费搭建查券返利机器人省钱赚佣金就用微赚淘客系统3.0的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！编写Spring Boot应用中与HBase交互的数据访问代码，包括表的创建、数据的插入和查询等操作。
基于Spring Boot框架的EAM系统设计与实现
追求卓越
07-05 764
当测试执行的结果与预设的“期望输出”出现偏差时，这即是明确的信号，表明系统中存在问题，随即开始调试，进行问题的深度剖析与修正，从而确保EAM系统的顺畅运行与高效管理能力。对企业资产进行科学分类，可以实现资源的精细化管理，帮助企业更好地掌握资产的分布、使用状况及折旧情况，进而优化资源配置，减少不必要的购置和维护成本，提升资产的整体效能。通过采用 Java、JSP、MySQL 数据库等先进的技术栈和面向服务的架构设计，该系统实现了高度的灵活性、可扩展性和安全性，确保了资产信息管理的全生命周期覆盖。
Spring Boot应用启动慢的原因分析及优化方法
技术萌新缓缓升级ing
07-05 1080
Spring Boot应用启动慢的原因有很多，涉及自动配置、依赖、数据加载、配置文件、外部服务、类加载、日志配置以及自定义初始化逻辑等多个方面。通过禁用不必要的自动配置、减少依赖、启用延迟初始化、优化数据加载、简化配置文件、优化类加载、合理配置日志以及优化自定义初始化逻辑等方法，可以显著提升Spring Boot应用的启动速度。
spring boot 集成Rsocket，服务端、客户端
weixin_41463944的博客
07-05 188
spring boot 集成Rsocket，服务端、客户端
在Spring Boot中实现RESTful API设计
微赚淘客开发者博客
07-08 353
RESTful API是一种设计风格，基于HTTP协议的一组约束和原则，用于创建具有良好可伸缩性和性能的Web服务。本文介绍了如何在Spring Boot中设计和实现RESTful API，包括使用HTTP方法、路径映射、请求和响应处理等关键步骤。通过遵循RESTful API设计原则，开发人员能够创建出易于理解、扩展和维护的Web服务。微赚淘客系统3.0小编出品，必属精品，转载请注明出处！
在Spring Boot项目中集成监控与报警
最新发布
微赚淘客开发者博客
07-08 329
本文详细介绍了在Spring Boot项目中集成监控与报警的方法，包括使用Actuator端点进行基本的监控配置、集成Spring Boot Admin进行高级监控和报警配置，以及使用Micrometer进行度量。Spring Boot作为广泛使用的Java框架，提供了丰富的支持来集成监控和报警功能，本文将介绍如何在Spring Boot项目中实现这些功能。通过Spring Boot Admin的界面，可以配置报警规则和通知方式，如邮件、Slack等，来实现对应用程序异常和重要指标的实时监控和报警通知。
通过Spring Boot结合实时流媒体技术对考试过程进行实时监控
八戒的博客
07-03 764
本章将深入探讨考试系统中常见的复杂技术问题，并提供基于Spring Boot 3.x的解决方案。涵盖屏幕切换检测与防护、接打电话识别处理、行为监控摄像头使用、网络不稳定应对等，每篇文章详细剖析问题并提供实际案例与代码示例，帮助开发者应对挑战，提升考试系统的安全性、稳定性与用户体验。
基于Spring Boot的在线考试系统
heye0910032的博客
07-01 794
在线考试系统的开发旨在利用Java技术和MySQL数据库，实现一个便捷高效的在线考试管理平台。该系统通过互联网广泛宣传，使教师和学生能够体验信息化管理带来的便利。系统设计考虑了需求、结构和数据库等方面，实现了管理员、学生和教师的不同功能需求。论文详细描述了系统的设计、实现、分析和测试过程，确保系统达到预期标准。通过本论文的研究与开发，我们成功构建了一个基于Spring Boot的在线考试系统。该系统具备用户友好的操作界面和高效的后台管理功能，能够满足不同用户角色的需求。
Spring Boot 创建定时任务
八戒的博客
07-02 1805
通过本文的介绍和示例代码，我们了解了如何在Spring Boot中创建和管理定时任务。Spring Boot的@Scheduled注解和TaskScheduler接口为定时任务提供了强大的支持，使得开发者能够轻松实现各种定时任务的需求。无论是简单的固定间隔任务，还是复杂的Cron表达式任务，Spring Boot都能提供简洁优雅的解决方案。在实际应用中，我们可能需要更复杂的定时任务管理功能，例如动态修改任务的执行时间、任务状态监控等。定时任务是指在预定的时间间隔或特定的时间点自动执行的任务。
java多线程存钱取钱_JAVA多线程----用--取钱问题1
06-02
好的，您的问题是关于Java多线程的存钱取钱问题。这是一个经典的多线程同步问题，可以通过使用synchronized关键字来实现线程安全。下面是一个简单的示例代码： ```java public class BankAccount { private int balance; public BankAccount(int balance) { this.balance = balance; } public synchronized void deposit(int amount) { balance += amount; System.out.println("Deposit successful. Balance: " + balance); } public synchronized void withdraw(int amount) { if (balance < amount) { System.out.println("Withdraw failed. Insufficient balance."); return; } balance -= amount; System.out.println("Withdraw successful. Balance: " + balance); } } public class Main { public static void main(String[] args) { BankAccount account = new BankAccount(1000); // Create two threads to simulate deposit and withdraw Thread depositThread = new Thread(() -> { for (int i = 0; i < 5; i++) { account.deposit(100); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }); Thread withdrawThread = new Thread(() -> { for (int i = 0; i < 5; i++) { account.withdraw(200); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }); depositThread.start(); withdrawThread.start(); } } ``` 在这个示例代码中，我们创建了一个银行账户类BankAccount，并在其中实现了deposit和withdraw方法，并使用synchronized关键字来保证线程安全。 在main方法中，我们创建了两个线程来模拟存款和取款操作，每个线程执行5次操作。我们使用Thread.sleep方法来模拟每个操作之间的间隔，以便更好地观察多线程操作的结果。 当多个线程同时访问BankAccount对象的deposit和withdraw方法时，synchronized关键字可以确保每个方法只能被一个线程访问，从而避免了竞争条件和数据不一致的问题。 希望这个示例代码能够回答您的问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值