通过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。

相关文章

Spring Boot3虚拟线程的使用步骤详解

Spring Boot3虚拟线程的使用步骤详解

《SpringBoot3虚拟线程的使用步骤详解》虚拟线程是Java19中引入的一个新特性,旨在通过简化线程管理来提升应用程序的并发性能,：本文主要介绍SpringBoot3虚拟线程的使用步骤,... 目录问题根源分析解决方案验证验证实验实验1：未启用keep-alive实验2：启用keep-alive扩展建
阅读更多...
Spring定时任务只执行一次的原因分析与解决方案

Spring定时任务只执行一次的原因分析与解决方案

《Spring定时任务只执行一次的原因分析与解决方案》在使用Spring的@Scheduled定时任务时,你是否遇到过任务只执行一次,后续不再触发的情况？这种情况可能由多种原因导致,如未启用调度、线程... 目录1. 问题背景2. Spring定时任务的基本用法3. 为什么定时任务只执行一次？3.1 未启用
阅读更多...
浅析CSS 中z - index属性的作用及在什么情况下会失效

浅析CSS 中z - index属性的作用及在什么情况下会失效

《浅析CSS中z-index属性的作用及在什么情况下会失效》z-index属性用于控制元素的堆叠顺序,值越大,元素越显示在上层,它需要元素具有定位属性（如relative、absolute、fi... 目录1. z-index 属性的作用2. z-index 失效的情况2.1 元素没有定位属性2.2 元素处
阅读更多...
Java终止正在运行的线程的三种方法

Java终止正在运行的线程的三种方法

《Java终止正在运行的线程的三种方法》停止一个线程意味着在任务处理完任务之前停掉正在做的操作,也就是放弃当前的操作,停止一个线程可以用Thread.stop()方法,但最好不要用它,本文给大家介绍了... 目录前言1. 停止不了的线程2. 判断线程是否停止状态3. 能停止的线程–异常法4. 在沉睡中停止5
阅读更多...
查看Oracle数据库中UNDO表空间的使用情况(最新推荐)

查看Oracle数据库中UNDO表空间的使用情况(最新推荐)

《查看Oracle数据库中UNDO表空间的使用情况(最新推荐)》Oracle数据库中查看UNDO表空间使用情况的4种方法：DBA_TABLESPACES和DBA_DATA_FILES提供基本信息,V$... 目录1. 通过 DBjavascriptA_TABLESPACES 和 DBA_DATA_FILES
阅读更多...
Java捕获ThreadPoolExecutor内部线程异常的四种方法

Java捕获ThreadPoolExecutor内部线程异常的四种方法

《Java捕获ThreadPoolExecutor内部线程异常的四种方法》这篇文章主要为大家详细介绍了Java捕获ThreadPoolExecutor内部线程异常的四种方法,文中的示例代码讲解详细,感... 目录方案 1方案 2方案 3方案 4结论方案 1使用 execute + try-catch 记录
阅读更多...
Go使用pprof进行CPU,内存和阻塞情况分析

Go使用pprof进行CPU,内存和阻塞情况分析

《Go使用pprof进行CPU,内存和阻塞情况分析》Go语言提供了强大的pprof工具,用于分析CPU、内存、Goroutine阻塞等性能问题,帮助开发者优化程序,提高运行效率,下面我们就来深入了解下... 目录1. pprof 介绍2. 快速上手：启用 pprof3. CPU Profiling：分析 C
阅读更多...
grom设置全局日志实现执行并打印sql语句

grom设置全局日志实现执行并打印sql语句

《grom设置全局日志实现执行并打印sql语句》本文主要介绍了grom设置全局日志实现执行并打印sql语句,包括设置日志级别、实现自定义Logger接口以及如何使用GORM的默认logger,通过这些... 目录gorm中的自定义日志gorm中日志的其他操作日志级别Debug自定义 Loggergorm中的
阅读更多...
MySQL进阶之路索引失效的11种情况详析

MySQL进阶之路索引失效的11种情况详析

《MySQL进阶之路索引失效的11种情况详析》：本文主要介绍MySQL查询优化中的11种常见情况,包括索引的使用和优化策略,通过这些策略,开发者可以显著提升查询性能,需要的朋友可以参考下... 目录前言图示1. 使用不等式操作符（!=, <, >）2. 使用 OR 连接多个条件3. 对索引字段进行计算操作4
阅读更多...
Spring Boot 中正确地在异步线程中使用 HttpServletRequest的方法

Spring Boot 中正确地在异步线程中使用 HttpServletRequest的方法

《SpringBoot中正确地在异步线程中使用HttpServletRequest的方法》文章讨论了在SpringBoot中如何在异步线程中正确使用HttpServletRequest的问题,... 目录前言一、问题的来源：为什么异步线程中无法访问 HttpServletRequest？1. 请求上下文与线
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2