Synchronized 的 8 种使用场景!

blog.csdn.net/x541211190/article/details/106272922

简介

本文将介绍8种同步方法的访问场景,我们来看看这8种情况下,多线程访问同步方法是否还是线程安全的。这些场景是多线程编程中经常遇到的,而且也是面试时高频被问到的问题,所以不管是理论还是实践,这些都是多线程场景必须要掌握的场景。

八种使用场景:

接下来,我们来通过代码实现,分别判断以下场景是不是线程安全的,以及原因是什么。

  1. 两个线程同时访问同一个对象的同步方法

  2. 两个线程同时访问两个对象的同步方法

  3. 两个线程同时访问(一个或两个)对象的静态同步方法

  4. 两个线程分别同时访问(一个或两个)对象的同步方法和非同步方法

  5. 两个线程访问同一个对象中的同步方法,同步方法又调用一个非同步方法

  6. 两个线程同时访问同一个对象的不同的同步方法

  7. 两个线程分别同时访问静态synchronized和非静态synchronized方法

  8. 同步方法抛出异常后,JVM会自动释放锁的情况

场景一:两个线程同时访问同一个对象的同步方法

分析:这种情况是经典的对象锁中的方法锁,两个线程争夺同一个对象锁,所以会相互等待,是线程安全的。

「两个线程同时访问同一个对象的同步方法,是线程安全的。」

场景二:两个线程同时访问两个对象的同步方法

这种场景就是对象锁失效的场景,原因出在访问的是两个对象的同步方法,那么这两个线程分别持有的两个线程的锁,所以是互相不会受限的。加锁的目的是为了让多个线程竞争同一把锁,而这种情况多个线程之间不再竞争同一把锁,而是分别持有一把锁,所以我们的结论是:

「两个线程同时访问两个对象的同步方法,是线程不安全的。」

代码验证:

public class Condition2 implements Runnable {  // 创建两个不同的对象  static Condition2 instance1 = new Condition2();  static Condition2 instance2 = new Condition2();  @Override  public void run() {  method();  }  private synchronized void method() {  System.out.println("线程名:" + Thread.currentThread().getName() + ",运行开始");  try {  Thread.sleep(4000);  } catch (InterruptedException e) {  e.printStackTrace();  }  System.out.println("线程:" + Thread.currentThread().getName() + ",运行结束");  }  public static void main(String[] args) {  Thread thread1 = new Thread(instance1);  Thread thread2 = new Thread(instance2);  thread1.start();  thread2.start();  while (thread1.isAlive() || thread2.isAlive()) {  }  System.out.println("测试结束");  }  
}  

运行结果:

两个线程是并行执行的,所以线程不安全。

线程名:Thread-0,运行开始  
线程名:Thread-1,运行开始  
线程:Thread-0,运行结束  
线程:Thread-1,运行结束  
测试结束  

代码分析:

「问题在此:」

两个线程(thread1、thread2),访问两个对象(instance1、instance2)的同步方法(method()),两个线程都有各自的锁,不能形成两个线程竞争一把锁的局势,所以这时,synchronized修饰的方法method()和不用synchronized修饰的效果一样(不信去把synchronized关键字去掉,运行结果一样),所以此时的method()只是个普通方法。

「如何解决这个问题:」

若要使锁生效,只需将method()方法用static修饰,这样就形成了类锁,多个实例(instance1、instance2)共同竞争一把类锁,就可以使两个线程串行执行了。这也就是下一个场景要讲的内容。

场景三:两个线程同时访问(一个或两个)对象的静态同步方法

这个场景解决的是场景二中出现的线程不安全问题,即用类锁实现:

「两个线程同时访问(一个或两个)对象的静态同步方法,是线程安全的。」

场景四:两个线程分别同时访问(一个或两个)对象的同步方法和非同步方法

这个场景是两个线程其中一个访问同步方法,另一个访问非同步方法,此时程序会不会串行执行呢,也就是说是不是线程安全的呢?
我们可以确定是线程不安全的,如果方法不加synchronized都是安全的,那就不需要同步方法了。验证下我们的结论:

「两个线程分别同时访问(一个或两个)对象的同步方法和非同步方法,是线程不安全的。」

public class Condition4 implements Runnable {  static Condition4 instance = new Condition4();  @Override  public void run() {  //两个线程访问同步方法和非同步方法  if (Thread.currentThread().getName().equals("Thread-0")) {  //线程0,执行同步方法method0()  method0();  }  if (Thread.currentThread().getName().equals("Thread-1")) {  //线程1,执行非同步方法method1()  www.xttblog.commethod1();  }  }  // 同步方法  private synchronized void method0() {  System.out.println("线程名:" + Thread.currentThread().getName() + ",同步方法,运行开始");  try {  Thread.sleep(4000);  } catch (InterruptedException e) {  e.printStackTrace();  }  System.out.println("线程:" + Thread.currentThread().getName() + ",同步方法,运行结束");  }  // 普通方法  private void method1() {  System.out.println("线程名:" + Thread.currentThread().getName() + ",普通方法,运行开始");  try {  Thread.sleep(4000);  } catch (InterruptedException e) {  e.printStackTrace();  }  System.out.println("线程:" + Thread.currentThread().getName() + ",普通方法,运行结束");  }  public static void main(String[] args) {  Thread thread1 = new Thread(instance);  Thread thread2 = new Thread(instance);  thread1.start();  thread2.start();  while (thread1.isAlive() || thread2.isAlive()) {  }  System.out.println("测试结束");  }  }  

运行结果:

两个线程是并行执行的,所以是线程不安全的。

线程名:Thread-0,同步方法,运行开始  
线程名:Thread-1,普通方法,运行开始  
线程:Thread-0,同步方法,运行结束  
线程:Thread-1,普通方法,运行结束  
测试结束  

结果分析

问题在于此:method1没有被synchronized修饰,所以不会受到锁的影响。即便是在同一个对象中,当然在多个实例中,更不会被锁影响了。结论:

「非同步方法不受其它由synchronized修饰的同步方法影响」

你可能想到一个类似场景:多个线程访问同一个对象中的同步方法,同步方法又调用一个非同步方法,这个场景会是线程安全的吗?

场景五:两个线程访问同一个对象中的同步方法,同步方法又调用一个非同步方法

我们来实验下这个场景,用两个线程调用同步方法,在同步方法中调用普通方法;再用一个线程直接调用普通方法,看看是否是线程安全的?

public class Condition8 implements Runnable {  static Condition8 instance = new Condition8();  @Override  public void run() {  if (Thread.currentThread().getName().equals("Thread-0")) {  //直接调用普通方法  method2();  } else {  // 先调用同步方法,在同步方法内调用普通方法  method1();  }  }  // 同步方法  private static synchronized void method1() {  System.out.println("线程名:" + Thread.currentThread().getName() + ",同步方法,运行开始");  try {  Thread.sleep(2000);  } catch (InterruptedException e) {  e.printStackTrace();  }  System.out.println("线程:" + Thread.currentThread().getName() + ",同步方法,运行结束,开始调用普通方法");  method2();  }  // 普通方法  private static void method2() {  System.out.println("线程名:" + Thread.currentThread().getName() + ",普通方法,运行开始");  try {  Thread.sleep(4000);  } catch (InterruptedException e) {  e.printStackTrace();  }  System.out.println("线程:" + Thread.currentThread().getName() + ",普通方法,运行结束");  }  public static void main(String[] args) {  // 此线程直接调用普通方法  Thread thread0 = new Thread(instance);  // 这两个线程直接调用同步方法  Thread thread1 = new Thread(instance);  Thread thread2 = new Thread(instance);  thread0.start();  thread1.start();  thread2.start();  while (thread0.isAlive() || thread1.isAlive() || thread2.isAlive()) {  }  System.out.println("测试结束");  }  }  

运行结果:

线程名:Thread-0,普通方法,运行开始  
线程名:Thread-1,同步方法,运行开始  
线程:Thread-1,同步方法,运行结束,开始调用普通方法  
线程名:Thread-1,普通方法,运行开始  
线程:Thread-0,普通方法,运行结束  
线程:Thread-1,普通方法,运行结束  
线程名:Thread-2,同步方法,运行开始  
线程:Thread-2,同步方法,运行结束,开始调用普通方法  
线程名:Thread-2,普通方法,运行开始  
线程:Thread-2,普通方法,运行结束  
测试结束  

结果分析:

我们可以看出,普通方法被两个线程并行执行,不是线程安全的。这是为什么呢?

因为如果非同步方法,有任何其他线程直接调用,而不是仅在调用同步方法时,才调用非同步方法,此时会出现多个线程并行执行非同步方法的情况,线程就不安全了。

对于同步方法中调用非同步方法时,要想保证线程安全,就必须保证非同步方法的入口,仅出现在同步方法中。但这种控制方式不够优雅,若被不明情况的人直接调用非同步方法,就会导致原有的线程同步不再安全。所以不推荐大家在项目中这样使用,但我们要理解这种情况,并且我们要用语义明确的、让人一看就知道这是同步方法的方式,来处理线程安全的问题。

所以,最简单的方式,是在非同步方法上,也加上synchronized关键字,使其变成一个同步方法,这样就变成了《场景五:两个线程同时访问同一个对象的不同的同步方法》,这种场景下,大家就很清楚的看到,同一个对象中的两个同步方法,不管哪个线程调用,都是线程安全的了。

所以结论是:

「两个线程访问同一个对象中的同步方法,同步方法又调用一个非同步方法,仅在没有其他线程直接调用非同步方法的情况下,是线程安全的。若有其他线程直接调用非同步方法,则是线程不安全的。」

场景六:两个线程同时访问同一个对象的不同的同步方法

这个场景也是在探讨对象锁的作用范围,对象锁的作用范围是对象中的所有同步方法。所以,当访问同一个对象中的多个同步方法时,结论是:

「两个线程同时访问同一个对象的不同的同步方法时,是线程安全的。」

public class Condition5 implements Runnable {  static Condition5 instance = new Condition5();  @Override  public void run() {  if (Thread.currentThread().getName().equals("Thread-0")) {  //线程0,执行同步方法method0()  method0();  }  if (Thread.currentThread().getName().equals("Thread-1")) {  //线程1,执行同步方法method1()  www.xttblog.commethod1();  }  }  private synchronized void method0() {  System.out.println("线程名:" + Thread.currentThread().getName() + ",同步方法0,运行开始");  try {  Thread.sleep(4000);  } catch (InterruptedException e) {  e.printStackTrace();  }  System.out.println("线程:" + Thread.currentThread().getName() + ",同步方法0,运行结束");  }  private synchronized void method1() {  System.out.println("线程名:" + Thread.currentThread().getName() + ",同步方法1,运行开始");  try {  Thread.sleep(4000);  } catch (InterruptedException e) {  e.printStackTrace();  }  System.out.println("线程:" + Thread.currentThread().getName() + ",同步方法1,运行结束");  }  //运行结果:串行  public static void main(String[] args) {  Thread thread1 = new Thread(instance);  Thread thread2 = new Thread(instance);  thread1.start();  thread2.start();  while (thread1.isAlive() || thread2.isAlive()) {  }  System.out.println("测试结束");  }  
}  

运行结果:

是线程安全的。

线程名:Thread-1,同步方法1,运行开始  
线程:Thread-1,同步方法1,运行结束  
线程名:Thread-0,同步方法0,运行开始  
线程:Thread-0,同步方法0,运行结束  
测试结束  

结果分析:

两个方法(method0()和method1())的synchronized修饰符,虽没有指定锁对象,但默认锁对象为this对象为锁对象,
所以对于同一个实例(instance),两个线程拿到的锁是同一把锁,此时同步方法会串行执行。这也是synchronized关键字的可重入性的一种体现。

场景七:两个线程分别同时访问静态synchronized和非静态synchronized方法

这种场景的本质也是在探讨两个线程获取的是不是同一把锁的问题。静态synchronized方法属于类锁,锁对象是(*.class)对象,非静态synchronized方法属于对象锁中的方法锁,锁对象是this对象。两个线程拿到的是不同的锁,自然不会相互影响。结论:

「两个线程分别同时访问静态synchronized和非静态synchronized方法,线程不安全。」

代码实现:

public class Condition6 implements Runnable {  static Condition6 instance = new Condition6();  @Override  public void run() {  if (Thread.currentThread().getName().equals("Thread-0")) {  //线程0,执行静态同步方法method0()  method0();  }  if (Thread.currentThread().getName().equals("Thread-1")) {  //线程1,执行非静态同步方法method1()  method1();  }  }  // 重点:用static synchronized 修饰的方法,属于类锁,锁对象为(*.class)对象。  private static synchronized void method0() {  System.out.println("线程名:" + Thread.currentThread().getName() + ",静态同步方法0,运行开始");  try {  Thread.sleep(4000);  } catch (InterruptedException e) {  e.printStackTrace();  }  System.out.println("线程:" + Thread.currentThread().getName() + ",静态同步方法0,运行结束");  }  // 重点:synchronized 修饰的方法,属于方法锁,锁对象为(this)对象。  private synchronized void method1() {  System.out.println("线程名:" + Thread.currentThread().getName() + ",非静态同步方法1,运行开始");  try {  Thread.sleep(4000);  } catch (InterruptedException e) {  e.printStackTrace();  }  System.out.println("线程:" + Thread.currentThread().getName() + ",非静态同步方法1,运行结束");  }  //运行结果:并行  public static void main(String[] args) {  //问题原因: 线程1的锁是类锁(*.class)对象,线程2的锁是方法锁(this)对象,两个线程的锁不一样,自然不会互相影响,所以会并行执行。  Thread thread1 = new Thread(instance);  Thread thread2 = new Thread(instance);  thread1.start();  thread2.start();  while (thread1.isAlive() || thread2.isAlive()) {  }  System.out.println("测试结束");  }  

运行结果:

线程名:Thread-0,静态同步方法0,运行开始  
线程名:Thread-1,非静态同步方法1,运行开始  
线程:Thread-1,非静态同步方法1,运行结束  
线程:Thread-0,静态同步方法0,运行结束  
测试结束  

场景八:同步方法抛出异常后,JVM会自动释放锁的情况

本场景探讨的是synchronized释放锁的场景:

「只有当同步方法执行完或执行时抛出异常这两种情况,才会释放锁。」

所以,在一个线程的同步方法中出现异常的时候,会释放锁,另一个线程得到锁,继续执行。而不会出现一个线程抛出异常后,另一个线程一直等待获取锁的情况。这是因为JVM在同步方法抛出异常的时候,会自动释放锁对象。

代码实现:

public class Condition7 implements Runnable {  private static Condition7 instance = new Condition7();  @Override  public void run() {  if (Thread.currentThread().getName().equals("Thread-0")) {  //线程0,执行抛异常方法method0()  method0();  }  if (Thread.currentThread().getName().equals("Thread-1")) {  //线程1,执行正常方法method1()  method1();  }  }  private synchronized void method0() {  System.out.println("线程名:" + Thread.currentThread().getName() + ",运行开始");  try {  Thread.sleep(4000);  } catch (InterruptedException e) {  e.printStackTrace();  }  //同步方法中,当抛出异常时,JVM会自动释放锁,不需要手动释放,其他线程即可获取到该锁  System.out.println("线程名:" + Thread.currentThread().getName() + ",抛出异常,释放锁");  throw new RuntimeException();  }  private synchronized void method1() {  System.out.println("线程名:" + Thread.currentThread().getName() + ",运行开始");  try {  Thread.sleep(4000);  } catch (InterruptedException e) {  e.printStackTrace();  }  System.out.println("线程:" + Thread.currentThread().getName() + ",运行结束");  }  public static void main(String[] args) {  Thread thread1 = new Thread(instance);  Thread thread2 = new Thread(instance);  thread1.start();  thread2.start();  while (thread1.isAlive() || thread2.isAlive()) {  }  System.out.println("测试结束");  }  }  

运行结果:

线程名:Thread-0,运行开始  
线程名:Thread-0,抛出异常,释放锁  
线程名:Thread-1,运行开始  
Exception in thread "Thread-0" java.lang.RuntimeException  at com.study.synchronize.conditions.Condition7.method0(Condition7.java:34)  at com.study.synchronize.conditions.Condition7.run(Condition7.java:17)  at java.lang.Thread.run(Thread.java:748)  
线程:Thread-1,运行结束  
测试结束  

结果分析:

可以看出线程还是串行执行的,说明是线程安全的。而且出现异常后,不会造成死锁现象,JVM会自动释放出现异常线程的锁对象,其他线程获取锁继续执行。

总结

本文总结了并用代码实现和验证了synchronized各种使用场景,以及各种场景发生的原因和结论。我们分析的理论基础都是synchronized关键字的锁对象究竟是谁?多个线程之间竞争的是否是同一把锁?根据这个条件来判断线程是否是安全的。所以,有了这些场景的分析锻炼后,我们在以后使用多线程编程时,也可以通过分析锁对象的方式,判断出线程是否是安全的,从而避免此类问题的出现。

本文涵盖了synchronized关键字的最重要的各种使用场景,也是面试官常常会问到的高频问题,是一篇值得大家仔细阅读和亲自动手实践的文章,喜欢本文请点赞和收藏。


往期推荐

线程池的7种创建方式,强烈推荐你用它...


求求你,别再用wait和notify了!


2020年终总结:新的“开始”


关注我,每天陪你进步一点点!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/545114.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

Python的threadpool模块

2019独角兽企业重金招聘Python工程师标准>>> Python的threadpool模块 这是一个使用python实现的线程池库。 安装 pip install threadpool 文档 http://gashero.yeax.com/?p44 http://www.chrisarndt.de/projects/threadpool/ 测试 使用一个20个线程的线程池进行测试…

MySql常用命令总结

1:使用SHOW语句找出在服务器上当前存在什么数据库:mysql> SHOW DATABASES;2:2、创建一个数据库MYSQLDATAmysql> CREATE DATABASE MYSQLDATA;3:选择你所创建的数据库mysql> USE MYSQLDATA; (按回车键出现Database changed 时说明操作成功!)4:查看…

硬核Redis总结,看这篇就够了!

高清思维导图已同步Git:https://github.com/SoWhat1412/xmindfile总感觉哪里不对,但是又说不上来1、基本类型及底层实现1.1、String用途:适用于简单key-value存储、setnx key value实现分布式锁、计数器(原子性)、分布式全局唯一ID。底层&…

sql 数字减去null_减去两个16位数字| 8086微处理器

sql 数字减去nullProblem: Write a program to subtract two 16-bit numbers where starting address is 2000 and the numbers are at 3000 and 3002 memory address and store result into 3004 and 3006 memory address. 问题:编写一个程序以减去两个16位数字(起…

Java 解决采集UTF-8网页空格变成问号乱码

http://blog.csdn.net/bob007/article/details/27098875 使用此方法转换后,在列表中看到的正常,但是在详情页的文本框中查看到的就是 了,只好过滤掉所有的空格 html html.replaceAll(UTFSpace, " ");改为html html.replaceAll(UT…

linux中如何改IP

修改IP永久生效按以下方法vi /etc/sysconfig/network-scripts/ifcfg-eth0(eth0,第一块网卡,如果是第二块则为eth1)按如下修改ipDEVICEeth0(如果是第二块刚为eth1)BOOTPROTOstaticIPADDR192.168.0.11(改成要…

文件写入的6种方法,这种方法性能最好

作者 | 王磊来源 | Java中文社群(ID:javacn666)转载请联系授权(微信ID:GG_Stone)在 Java 中操作文件的方法本质上只有两种:字符流和字节流,而字节流和字符流的实现类又有很多&#x…

单位矩阵属性(I ^ k = I)| 使用Python的线性代数

Prerequisites: 先决条件: numpy.matmul( ) matrix multiplication numpy.matmul()矩阵乘法 Identity matrix 身份矩阵 In linear algebra, the identity matrix, of size n is the n n square matrix with ones on the main diagonal and zeros elsewhere. It is…

linux 更改文件权限(子文件夹)

加入-R 参数,就可以将读写权限传递给子文件夹例如chmod -R 777 /home/mypackage那么mypackage 文件夹和它下面的所有子文件夹的属性都变成了777.777是读、写、执行权限...

JavaScript中带有示例的Math.cos()方法

JavaScript | Math.cos()方法 (JavaScript | Math.cos() Method) Math.cos() is a function in math library of JavaScript that is used to find the value of cosine of a number and return the value in radians. Math.cos()是JavaScript数学库中的一个函数,用…

JDK 16 即将发布,新特性速览!

你还能追上 Java 的更新速度吗?当开发者深陷 Java 8 版本之际,这边下一版本 Java 16 有了最新的消息,与 Java 15 一样,作为短期版本,Oracle 仅提供 6 个月的支持。根据发布计划,JDK 16 将在 12 月 10 日和 …

SQL手动注入

随着B/S模式应用开发的发展,使用这种模式编写应用程序的程序员也越来越多。但是由于这个行业的入门门槛不高,程序员的水平及经验也参差不齐,相当大一部分程序员在编写代码的时候,没有对用户输入数据的合法性进行判断,使…

最牛逼的 Java 项目实战,没有之一!

想要成长为高级开发,掌握更多层面的技术,兼顾深度和广度是毋庸置疑的。你肯定认为,我要认真努力的学习技术,丰富自己的技术栈,然后就可以成为一个优秀的高级开发了。但当你真正去学习之后就会发现,技术栈异…

ArcPad 10 的安装部署

ArcPad是安装在手持设备或者移动终端的一个外业ArcGIS产品,也就是说ArcPad是Esri的一款软件产品,而不是硬件设备哦。尽管不比ArcGIS Desktop功能复杂缤纷,可是对于野外作业、数据採集等工作来说,算是功能十分丰富了。 说到安装&am…

python 获取当前目录_如何在Python中获取当前的工作目录?

python 获取当前目录To get the current working directory in Python, there is a library function getcwd() in the os module. 为了在Python中获得当前的工作目录, os模块中有一个库函数getcwd() 。 getcwd() function does not accept any parameter and retu…

定时任务的实现原理,看完就能手撸一个!

一、摘要在很多业务的系统中,我们常常需要定时的执行一些任务,例如定时发短信、定时变更数据、定时发起促销活动等等。在上篇文章中,我们简单的介绍了定时任务的使用方式,不同的架构对应的解决方案也有所不同,总结起来…

linux localhost的修改

在论坛上看到有一些需要更改/proc/sys/kernel/hostname才行 linux修改主机名的方法 用hostname命令可以临时修改机器名,但机器重新启动之后就会恢复原来的值。 #hostname //查看机器名 #hostname -i //查看本机器名对应的ip地址 另外一种方法就是之久修改配置文件…

ARC和MRC 兼容的单例模式

一、ARC下的单例实现说明:在用户实例化的方法控制单次执行,同时开放单例的初始化方法。 -(instancetype)init{self[super init];if(self){static dispatch_once_t onceToken;dispatch_once(&onceToken, ^{});}return self;}static id instance; (in…

scala 函数中嵌套函数_Scala中的嵌套函数 用法和示例

scala 函数中嵌套函数Scala中的嵌套函数 (Nested functions in Scala) A nested function is defined as a function which is defined inside the definition of another function. Programming languages like c, java, etc do not support nested functions but Scala does.…

Spring Boot集成Redis,这个坑把我害惨了!

最近项目中使用SpringBoot集成Redis,踩到了一个坑:从Redis中获取数据为null,但实际上Redis中是存在对应的数据的。是什么原因导致此坑的呢?本文就带大家从SpringBoot集成Redis、所踩的坑以及自动配置源码分析来学习一下SpringBoot…