通过8种加锁情况来弄懂加锁对于线程执行顺序的影响

2024-04-12 06:36
文章标签 线程 执行 顺序 情况 加锁 影响 弄懂

本文主要是介绍通过8种加锁情况来弄懂加锁对于线程执行顺序的影响，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

  • 1个资源类对象，2个线程，2个同步方法，第二个线程等待1s后开启。
//资源类
public class Example {//2个同步方法public synchronized void method1(){System.out.println("线程1正在执行...");}public synchronized void method2(){System.out.println("线程2正在执行...");}
}//开启线程
public class Main {public static void main(String[] args) throws InterruptedException {//1个资源类对象Example example=new Example();//创建并开启2个线程new Thread(()->{example.method1();}).start();//第二个线程延时1s创建并开启TimeUnit.SECONDS.sleep(1);new Thread(()->{example.method2();}).start();}
}

        先输出那个语句呢？

        运行结果：

        线程1和线程2使用的是同一个对象调用的同步方法，所以这两个线程需要竞争同一个锁。而线程1先运行，线程2延迟1s后才被创建，所以这1s期间只有线程1在竞争锁，就必然是线程1先获得锁，线程2只能等待线程1执行完后才能获得锁，然后才可以执行。这里面锁是很重要的，如果没有锁线程2完全可以在线程1执行期间抢夺CPU的占用权，并且如果线程1和线程2都需要较长的运行时间，那么谁最后执行完就不一定了。

  • 1个资源类对象，2个线程，2个同步方法，第一个线程开启后休眠3s，第二个线程等待1s后开启。
//资源类
public class Example {//2个同步方法public synchronized void method1() throws InterruptedException {//开启后先休眠3sTimeUnit.SECONDS.sleep(3);System.out.println("线程1正在执行...");}public synchronized void method2(){System.out.println("线程2正在执行...");}
}//开启两个线程
public class Main {public static void main(String[] args) throws InterruptedException {//1个资源类对象Example example=new Example();//创建并开启2个线程new Thread(()->{try {example.method1();} catch (InterruptedException e) {throw new RuntimeException(e);}}).start();//第二个线程延时1s创建并开启TimeUnit.SECONDS.sleep(1);new Thread(()->{example.method2();}).start();}
}

        先输出那个语句呢？

        运行结果：

        对比上面的情况，线程1在开启后先休眠3s，这对于执行结果是没有影响的。因为线程在调用sleep后进入计时等待状态，在此状态下如果已经获取了锁则不会释放，也就是抱着锁睡觉；区别于wait，调用wait后线程进入等待状态，在此期间如果之前已经获得了锁则会释放。 所以虽然休眠了3s，但线程1仍旧持有锁，线程2只能等待。

  • 1个资源类对象，2个线程，1个同步方法+1个普通方法，第一个线程开启后休眠3s。
//资源类
public class Example {//1个同步方法public synchronized void method1() throws InterruptedException {//开启后休眠3s            TimeUnit.SECONDS.sleep(3);System.out.println("线程1正在执行...");}//1个普通方法public void method2(){System.out.println("线程2正在执行...");}
}//创建两个线程
public class Main {public static void main(String[] args) throws InterruptedException {//1个资源类对象Example example=new Example();//创建并开启2个线程new Thread(()->{try {example.method1();} catch (InterruptedException e) {throw new RuntimeException(e);}}).start();new Thread(()->{example.method2();}).start();}
}

        先输出那个语句呢？

        运行结果：

        虽然线程1先获得了锁，并且sleep休眠期间也持有锁，但线程2调用的方法是普通方法，不需要获得锁即可执行。加锁只能防止其他需要获得同一把锁的线程，并不能防止不需要锁或者需要其他锁的线程，所以这种情况下锁就没有用了，线程1先获得了CPU占用权，随后休眠期间CPU被线程2抢走并执行，3s足以让线程2执行完毕，休眠结束后线程1再执行。

  • 2个资源类对象分别开启1个线程，2个同步方法，第一个线程开启后休眠3s，第二个线程等待1s后开启。
//资源类
public class Example {//2个同步方法public synchronized void method1() throws InterruptedException {//先休眠3sTimeUnit.SECONDS.sleep(3);System.out.println("线程1正在执行...");}public synchronized void method2(){System.out.println("线程2正在执行...");}
}//创建两个线程
public class Main {public static void main(String[] args) throws InterruptedException {//2个资源类对象Example example1=new Example();Example example2=new Example();//2个资源类对象分别创建并开启1个线程new Thread(()->{try {example1.method1();} catch (InterruptedException e) {throw new RuntimeException(e);}}).start();//第二个线程等待1s后创建TimeUnit.SECONDS.sleep(1);new Thread(()->{example2.method2();}).start();}
}

        先输出那个语句呢？

        运行结果：

        非静态同步方法使用的锁对象是this，也就是方法的调用者，而本案例中使用的是两个不同的资源类对象分别创建的线程，所以两个同步方法使用的锁对象是不一样的，第一个线程使用的锁对象是example1，第二个使用的是example2；上面的案例中谈到加锁并不能防止不需要锁或者需要其他锁的线程，所以虽然线程1先抢到了锁，但是在休眠的3s内CPU是线程2的，并且线程2需要获取的是另一把锁，这就使得线程2会比线程1先执行完。

  • 1个资源类对象，2个线程，2个静态同步方法，第一个线程开启后休眠3s，第二个线程等待1s后开启。
//资源类
public class Example {//2个静态同步方法public static synchronized void method1() throws InterruptedException {//先休眠3sTimeUnit.SECONDS.sleep(3);System.out.println("线程1正在执行...");}public static synchronized void method2(){System.out.println("线程2正在执行...");}
}//创建两个线程
public class Main {public static void main(String[] args) throws InterruptedException {//1个资源类对象Example example=new Example();//创建并开启2个线程new Thread(()->{try {example.method1();} catch (InterruptedException e) {throw new RuntimeException(e);}}).start();//第二个线程等待1s后创建TimeUnit.SECONDS.sleep(1);new Thread(()->{example.method2();}).start();}
}

        先输出那个语句呢？

        运行结果：

        静态同步方法的锁对象使用的是类的Class对象，而这个Class对象一个类只有一个，所以同一个类下所有静态同步方法的锁对象是同一个，即这个类的Class对象。那为什么会选择Class对象作为锁呢？这是因为静态方法和Class对象在类加载阶段就已经加载好了，但创建的对象需要等到类加载后执行到创建对象的代码时才会创建，只能选择Class对象作为锁对象。

        既然锁对象是同一个，并且线程1先抢到锁，那必然是线程1先执行，线程2后执行了。

  • 2个资源类对象分别开启1个线程，2个静态同步方法，第一个线程开启后休眠3s，第二个线程等待1s后开启。
//资源类
public class Example {//2个静态同步方法public static synchronized void method1() throws InterruptedException {//先休眠3sTimeUnit.SECONDS.sleep(3);System.out.println("线程1正在执行...");}public static synchronized void method2(){System.out.println("线程2正在执行...");}
}//创建两个线程
public class Main {public static void main(String[] args) throws InterruptedException {//2个资源类对象Example example1=new Example();Example example2=new Example();//两个对象各创建并开启1个线程new Thread(()->{try {example1.method1();} catch (InterruptedException e) {throw new RuntimeException(e);}}).start();//第二个线程等待1s后创建TimeUnit.SECONDS.sleep(1);new Thread(()->{example2.method2();}).start();}
}

        先输出那个语句呢？

        运行结果：

        上面说到同一个类中所有静态的同步方法使用的锁对象都是这个类的Class对象，那么在这个案例中，不同的资源类对象对锁对象没有影响，线程1和线程2需要获取的锁是一样的。由于线程1先获取到锁，所以线程1先执行，线程2后执行。

  • 1个资源类对象，2个线程，1个静态同步方法+1个同步方法，第一个线程开启后休眠3s，第二个线程等待1s后开启。
//资源类
public class Example {//1个静态同步方法public static synchronized void method1() throws InterruptedException {//先休眠3sTimeUnit.SECONDS.sleep(3);System.out.println("线程1正在执行...");}//1个同步方法public synchronized void method2(){System.out.println("线程2正在执行...");}
}//创建两个线程
public class Main {public static void main(String[] args) throws InterruptedException {//1个资源类对象Example example=new Example();//创建并开启2个线程new Thread(()->{try {example.method1();} catch (InterruptedException e) {throw new RuntimeException(e);}}).start();//第二个线程等待1s后创建TimeUnit.SECONDS.sleep(1);new Thread(()->{example.method2();}).start();}
}

        先输出那个语句呢？

        运行结果：

        对于线程1，静态方法的锁对象是Example.class；对于线程2，非静态同步方法的锁对象是方法调用者，即example，所以两个线程需要获取的锁是不同的，那么线程2就会在线程1休眠的时间里先执行完。

  • 2个资源类对象分别开启1个线程，1个静态同步方法+1个同步方法，第一个线程开启后休眠3s，第二个线程等待1s后开启。
//资源类
public class Example {//1个静态同步方法public static synchronized void method1() throws InterruptedException {//先休眠3sTimeUnit.SECONDS.sleep(3);System.out.println("线程1正在执行...");}//1个同步方法public synchronized void method2(){System.out.println("线程2正在执行...");}
}//创建两个线程
public class Main {public static void main(String[] args) throws InterruptedException {//2个资源类对象Example example1=new Example();Example example2=new Example();//2个对象各创建并开启1个线程new Thread(()->{try {example1.method1();} catch (InterruptedException e) {throw new RuntimeException(e);}}).start();//第二个线程等待1s后创建TimeUnit.SECONDS.sleep(1);new Thread(()->{example2.method2();}).start();}
}

        先输出那个语句呢？

        运行结果：

          对于线程1，静态方法的锁对象是Example.class；对于线程2，非静态同步方法的锁对象是方法调用者，即example2，所以两个线程需要获取的锁是不同的，那么线程2就会在线程1休眠的时间里先执行完。

这篇关于通过8种加锁情况来弄懂加锁对于线程执行顺序的影响的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/896369。

相关文章

C++统计函数执行时间的最佳实践

C++统计函数执行时间的最佳实践

《C++统计函数执行时间的最佳实践》在软件开发过程中,性能分析是优化程序的重要环节,了解函数的执行时间分布对于识别性能瓶颈至关重要,本文将分享一个C++函数执行时间统计工具,希望对大家有所帮助... 目录前言工具特性核心设计1. 数据结构设计2. 单例模式管理器3. RAII自动计时使用方法基本用法高级用法
阅读更多...
Java实现远程执行Shell指令

Java实现远程执行Shell指令

《Java实现远程执行Shell指令》文章介绍使用JSch在SpringBoot项目中实现远程Shell操作,涵盖环境配置、依赖引入及工具类编写,详解分号和双与号执行多指令的区别... 目录软硬件环境说明编写执行Shell指令的工具类总结jsch(Java Secure Channel)是SSH2的一个纯J
阅读更多...
Java中如何正确的停掉线程

Java中如何正确的停掉线程

《Java中如何正确的停掉线程》Java通过interrupt()通知线程停止而非强制,确保线程自主处理中断,避免数据损坏,线程池的shutdown()等待任务完成,shutdownNow()强制中断... 目录为什么不强制停止为什么 Java 不提供强制停止线程的能力呢？如何用interrupt停止线程s
阅读更多...
sysmain服务可以禁用吗? 电脑sysmain服务关闭后的影响与操作指南

sysmain服务可以禁用吗? 电脑sysmain服务关闭后的影响与操作指南

《sysmain服务可以禁用吗?电脑sysmain服务关闭后的影响与操作指南》在Windows系统中，SysMain服务（原名Superfetch）作为一个旨在提升系统性能的关键组件，一直备受用户关... 在使用 Windows 系统时，有时候真有点像在「开盲盒」。全新安装系统后的「默认设置」，往往并不尽编
阅读更多...
python 线程池顺序执行的方法实现

python 线程池顺序执行的方法实现

《python线程池顺序执行的方法实现》在Python中,线程池默认是并发执行任务的,但若需要实现任务的顺序执行,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋... 目录方案一：强制单线程（伪顺序执行）方案二：按提交顺序获取结果方案三：任务间依赖控制方案四：队列顺序消
阅读更多...
Go语言连接MySQL数据库执行基本的增删改查

Go语言连接MySQL数据库执行基本的增删改查

《Go语言连接MySQL数据库执行基本的增删改查》在后端开发中,MySQL是最常用的关系型数据库之一,本文主要为大家详细介绍了如何使用Go连接MySQL数据库并执行基本的增删改查吧... 目录Go语言连接mysql数据库准备工作安装 MySQL 驱动代码实现运行结果注意事项Go语言执行基本的增删改查准备工作
阅读更多...
Go语言使用sync.Mutex实现资源加锁

Go语言使用sync.Mutex实现资源加锁

《Go语言使用sync.Mutex实现资源加锁》数据共享是一把双刃剑,Go语言为我们提供了sync.Mutex,一种最基础也是最常用的加锁方式,用于保证在任意时刻只有一个goroutine能访问共享... 目录一、什么是 Mutex二、为什么需要加锁三、实战案例：并发安全的计数器1. 未加锁示例（存在竞态）
阅读更多...
SpringBoot实现虚拟线程的方案

SpringBoot实现虚拟线程的方案

《SpringBoot实现虚拟线程的方案》Java19引入虚拟线程,本文就来介绍一下SpringBoot实现虚拟线程的方案,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,... 目录什么是虚拟线程虚拟线程和普通线程的区别SpringBoot使用虚拟线程配置@Async性能对比H
阅读更多...
在Java中实现线程之间的数据共享的几种方式总结

在Java中实现线程之间的数据共享的几种方式总结

《在Java中实现线程之间的数据共享的几种方式总结》在Java中实现线程间数据共享是并发编程的核心需求,但需要谨慎处理同步问题以避免竞态条件,本文通过代码示例给大家介绍了几种主要实现方式及其最佳实践,... 目录1. 共享变量与同步机制2. 轻量级通信机制3. 线程安全容器4. 线程局部变量（ThreadL
阅读更多...
Linux线程同步/互斥过程详解

Linux线程同步/互斥过程详解

《Linux线程同步/互斥过程详解》文章讲解多线程并发访问导致竞态条件,需通过互斥锁、原子操作和条件变量实现线程安全与同步,分析死锁条件及避免方法,并介绍RAII封装技术提升资源管理效率... 目录01. 资源共享问题1.1 多线程并发访问1.2 临界区与临界资源1.3 锁的引入02. 多线程案例2.1 为
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2