深入理解synchronized关键字

最新推荐文章于 2024-10-30 10:20:22 发布
最新推荐文章于 2024-10-30 10:20:22 发布
阅读量100 收藏
点赞数
文章标签： java 运维
原文链接：http://www.cnblogs.com/-Marksman/p/10232382.html
版权

 

深入理解synchronized关键字

synchronized是并发编程中重要的使用工具之一，我们必须学会使用并且掌握它的原理。

概念及作用

JVM自带的关键字，可在需要线程安全的业务场景中使用，来保证线程安全。

用法

按照锁的对象区分可以分为对象锁和类锁
按照在代码中的位置区分可以分为方法形式和代码块形式

对象锁

锁对象为当前this或者说是当前类的实例对象

 public void synchronized method(){
    System.out.println("我是普通方法形式的对象锁");
 }
 public void method(){
     synchronized(this){
     　　System.out.println("我是代码块形式的对象锁");
　　　}
 }

类锁

锁的是当前类或者指定类的Class对象。一个类可能有多个实例对象，但它只可能有一个Class对象。

public static void synchronized method(){
　　System.out.println("我是静态方法形式的类锁");
}
public void method(){
　　synchronized(*.class){
　　　　System.out.println("我是代码块形式的类锁");
　　}
}

SimpleExample

[参考] https://www.imooc.com/learn/1086 【慕课网，Java高并发之魂：synchronized深度解析】

最基本的用法在上一个标题用法中已将伪代码列出，这里列举在以上基础上稍微变化一些的用法
1.多个实例，对当前实例加锁，同步执行，对当前类Class对象加锁，异步执行

public class SimpleExample implements Runnable{
　　static SimpleExample instance1 = new SimpleExample();
　　static SimpleExample instance2 = new SimpleExample();

　　@Override
　　public void run(){
　　　　method1();
　　　　method2();
　　　　method3();
　　　　method4();
　　}

　　public synchronized void method1(){
　　　　common();
　　}

　　public static synchronized void method2(){
　　　　commonStatic();
　　}

　　public void method3(){
　　　　synchronized(this){
　　　　　　common();
　　　　}
　　}

　　public void method4(){
　　　　synchronized(MultiInstance.class){
　　　　　　common();
　　　　}
　　}

　　public void method5(){
　　　　common();
　　}

　　public void method6(){
　　　　commonStatic();
　　}

　　public void common(){
　　　　System.out.println("线程 "+Thread.currentThread().getName()+" 正在执行");
　　　　try{
　　　　　　Thread.sleep(1000);
　　　　}catch(InterruptedException e){
　　　　　　e.printStackTrace();
　　　　}
　　　　System.out.println("线程 "+Thread.currentThread().getName()+" 执行完毕");
　　}

　　public static void commonStatic(){
　　　　System.out.println("线程 "+Thread.currentThread().getName()+" 正在执行");
　　　　try{
　　　　　　Thread.sleep(1000);
　　　　}catch(InterruptedException e){
　　　　　　e.printStackTrace();
　　　　}
　　　　System.out.println("线程 "+Thread.currentThread().getName()+" 执行完毕");
　　}
　　public static void main(String[] args)throws InterruptedException{
　　　　Thread t1 = new Thread(instance1);
　　　　Thread t2 = new Thread(instance2);
　　　　t1.start();
　　　　t2.start();
　　　　t1.join();
　　　　t2.join();
　　　　System.out.println("finished");
　　}
}
method1()、method3()结果为：
线程Thread-0正在执行
线程Thread-1正在执行
线程Thread-0执行完毕
线程Thread-1执行完毕
finished

method2()、method4()执行结果为：
线程Thread-0正在执行
线程Thread-0执行完毕
线程Thread-1正在执行
线程Thread-1执行完毕
finished

2.对象锁和类锁，锁的对象不一样，互不影响，所以异步执行

// 将run方法改为
@Override
public void run(){
　　if("Thread-0".equals(Thread.currentThread().getName())){
　　　　method1();
　　}else{
　　　　method2();
}
}
// 将main方法改为
public static void main(String[] args) throws InterruptedException{
Thread t1 = new Thread(instance1);
Thread t2 = new Thread(instance1);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("finished");
}
结果为：
线程Thread-0正在执行
线程Thread-1正在执行
线程Thread-1执行完毕
线程Thread-0执行完毕
finished

 

3.对象锁和无锁得普通方法，普通方法不需要持有锁，所以异步执行

// 将run方法改为
@Override
public void run(){
　　if("Thread-0".equals(Thread.currentThread().getName())){
　　　　method1();
　　}else{
　　　　method5();
　　}
}
// main方法同 2
结果为：
线程Thread-0正在执行
线程Thread-1正在执行
线程Thread-0执行完毕
线程Thread-1执行完毕
finished

4.类锁和无锁静态方法，异步执行

// 将run方法改为
@Override
public void run(){
　　if("Thread-0".equals(Thread.currentThread().getName())){
　　　　method1();
　　}else{
　　　　method6();
　　}
}
// main方法同 2
结果为：
线程Thread-0正在执行
线程Thread-1正在执行
线程Thread-0执行完毕
线程Thread-1执行完毕
finished

5.方法抛出异常，synchronized锁自动释放

// run方法改为
@Override
public void run(){
　　if("Thread-0".equals(Thread.currentThread().getName())){
　　　　method7();
　　}else{
　　　　method8();
　　}
}
public synchronized void method7(){
　　try{
　　　　...
　　　　throw new Exception();
　　}catch(Exception e){
　　　　e.printStackTrace();
　　}
}
public synchronized void method8(){
　　common();
}
public static void main(String[] args) throws InterruptedException{
　　// 同 2
}
结果为：
线程Thread-0正在执行
java.lang.Exception
at com.marksman.theory2practicehighconcurrency.synchronizedtest.blog.SynchronizedException.method7(SynchronizedException.java:26)
at com.marksman.theory2practicehighconcurrency.synchronizedtest.blog.SynchronizedException.run(SynchronizedException.java:15)
at java.lang.Thread.run(Thread.java:748)
线程Thread-0执行结束
线程Thread-1正在执行
线程Thread-1执行结束
finished
// 这说明抛出异常后持有对象锁的method7()方法释放了锁，这样method8()才能获取到锁并执行。

6.可重入特性

public class SynchronizedRecursion{
　　int a =0;
　　int b =0;
　　private void method1(){
　　　　System.out.println("method1正在执行，a = "+ a);
　　　　if(a ==0){
　　　　　　a ++;
　　　　　　method1();
　　　　}
　　　　System.out.println("method1执行结束，a = "+ a);
　　}
　　private synchronized void method2(){
　　　　System.out.println("method2正在执行，b = "+ b);
　　　　if(b == 0){
　　　　　　b ++;
　　　　　　method2();
　　　　}
　　　　System.out.println("method2执行结束，b = "+ b);
　　}
　　public static void main(String[] args){
　　　　SynchronizedRecursion synchronizedRecursion = new SynchronizedRecursion();
　　　　synchronizedRecursion.method1();
　　　　synchronizedRecursion.method2();
　　}
}
结果为：
method1正在执行，a =0
method1正在执行，a =1
method1执行结束，a =1
method1执行结束，a =1
method2正在执行，b =0
method2正在执行，b =1
method2执行结束，b =1
method2执行结束，b =1
// 可以看到method1()与method2()的执行结果一样的，method2()在获取到对象锁以后，在递归调用时不需要等上一次调用先释放后再获取，而是直接进入，这说明了synchronized的可重入性.
// 当然，除了递归调用，调用同类的其它同步方法，调用父类同步方法，都是可重入的，前提是同一对象去调用，这里就不一一列举了.

总结一下

  • 一把锁只能同时被一个线程获取，没有拿到锁的线程必须等待；
  • 每个实例都对应有自己的一把锁，不同实例之间互不影响；
  • 锁对象是*.class以及synchronized修饰的static方法时，所有对象共用一把类锁；
  • 无论是方法正常执行完毕或者方法抛出异常，都会释放锁；
  • 使用synchronized修饰的方法都是可重入的。

synchronized的实现原理

monitorenter和monitorexit

将下面两段代码分别用 javac *.java编译成.class文件，再反编译 javap -verbose *.class文件

public class SynchronizedThis{
　　public void method(){
　　　　synchronized(this){}
　　}
}
// 反编译结果
public void method();
descriptor:()V
flags: ACC_PUBLIC
Code:
stack=2, locals=3, args_size=1
0: aload_0
1: dup
2: astore_1
3: monitorenter
4: aload_1
5: monitorexit
6:goto14
9: astore_2
10: aload_1
11: monitorexit
12: aload_2
13: athrow
14:return
 
public class SynchronizedMethod{
　　public synchronized void method(){}
}
// 反编译结果
public synchronized void method();
descriptor:()V
flags: ACC_PUBLIC, ACC_SYNCHRONIZED
Code:
stack=0, locals=1, args_size=1
0:return
LineNumberTable:
line 2:0

可以看到：

  • synchronized加在代码块上，JVM是通过monitorenter和monitorexit来控制锁的获取的释放的；
  • synchronized加在方法上，JVM是通过ACC_SYNCHRONIZED来控制的，但本质上也是通过monitorenter和monitorexit指令控制的。

对象头

[参考]  https://www.jianshu.com/p/3d38cba67f8b 【简书，Java对象头详解】

上面我们提到monitor，这是什么鬼？
其实，对象在内存是这样存储的，包括对象头、实例数据和对齐填充Padding，其中对象头包括
Mark Word和类型指针。

Mark Word

Mark Word用于存储对象自身的运行时数据，如哈希码（identity_hashcode）、GC分代年龄(age)、锁状态标志(lock)、线程持有的锁、偏向线程ID(thread)、偏向时间戳(epoch)等等，占用内存大小与虚拟机位长一致。

Mark Word (32 bits)State 锁状态
identity_hashcode:25 | age:4 | biased_lock:1 | lock:2Normal 无锁
thread:23 | epoch:2 | age:4 | biased_lock:1 | lock:2Biased 偏向锁
ptr_to_lock_record:30 | lock:2Lightweight Locked 轻量级锁
ptr_to_heavyweight_monitor:30 | lock:2Heavyweight Locked 重量级锁
| lock:2Marked for GC GC标记

 

Mark Word (64 bits)State 锁状态
unused:25|identity_hashcode:31|unused:1|age:4|biased_lock:1|lock:2Normal 无锁
thread:54 |epoch:2|unused:1|age:4|biased_lock:1|lock:2Biased 偏向锁
ptr_to_lock_record:62 | lock:2Lightweight Locked 轻量级锁
ptr_to_heavyweight_monitor:62 | lock:2Heavyweight Locked 重量级锁
| lock:2Marked for GC GC标记

可以看到，monitor就存在Mark Word中。

类型指针

类型指针指向对象的类元数据metadata，虚拟机通过这个指针确定该对象是哪个类的实例。

锁状态
biased_locklock状态
001无锁
101偏向锁
000轻量级锁
010重量级锁
011GC标记
 

JDK对synchronized的优化

jdk1.6之前synchronized是很重的，所以并不被开发者偏爱，随着后续版本jdk对synchronized的优化使其越来越轻量，它还是很好用的，甚至ConcurrentHashMap在jdk的put方法都在jdk1.8时从ReetrantLock.tryLock()改为用synchronized来实现同步。
并且还引入了偏向锁，轻量级锁等概念，下面是偏向锁和轻量级锁的获取流程

 

![偏向锁和轻量级锁的获取流程] https://i-blog.csdnimg.cn/blog_migrate/e54a1495824185c1a9a441014c229a14.png 【ProncessOn 公开克隆】


[参考] 链接：https://pan.baidu.com/s/1gA_URintNDiq_SuAbJQE2Q 提取码：s6vx 【咕泡学院公开课】

偏向锁 baised_lock

如果一个线程获取了偏向锁，那么如果在接下来的一段时间里，如果没有其他线程来抢占锁，那么获取锁的线程在下一次进入方法时不需要重新获取锁。

 

synchronized与ReentrantLock的区别

[参考] https://time.geekbang.org/column/article/8799 【极客时间，Java核心技术36讲专栏】

区别synchronizedReentrantLock
灵活性代码简单，自动获取、释放锁相对繁琐，需要手动获取、释放锁
是否可重入是是
作用位置可作用在方法和代码块只能用在代码块
获取、释放锁的方式monitorenter、monitorexit、ACC_SYNCHRONIZED尝试非阻塞获取锁tryLock()、超时获取锁tryLock(long timeout,TimeUnit unit)、unlock()
获取锁的结果不知道可知，tryLock()返回boolean
使用注意事项

1、锁对象不能为空（锁保存在对象头中，null没有对象头）

2、作用域不宜过大

1、切记要在finally中unlock()，否则会形成死锁

2、不要将获取锁的过程写在try块内，因为如果在获取锁时发生了异常，异常抛出的同时，也会导致锁无故被释放。

 

 

转载于:https://www.cnblogs.com/-Marksman/p/10232382.html

dijia7248
关注
synchronize深入理解
爱与不爱，一念之间
11-30 2394
在上一篇章中对synchronize的一些常见用法进行了分析，主要就是 synchronize 修饰的同步方法还是静态方法，锁对象还是类 https://editor.csdn.net/md/?articleId=90712939 然而对于一个程序员来说，光总结可不行，我们要探究为什么会出现这种现象，是什么根本的东西在。 一、反编译（使用synchronize 同步代码块） 这里有两种方法 1）...
java synchronized 递归_Java并发之synchronized深入
weixin_39821718的博客
02-13 230
原标题：Java并发之synchronized深入 一句话总结synchronized：JVM会自动通过使用monitor来加锁和解锁，保证了同时只有一个线程可以执行指定代码，从而保证了线程安全，同时具有可重入和不可中断的性质。一.synchronized的作用使用synchronized修饰方法或者代码块时，它能够保证在同一时刻最多只有一个线程执行该段代码，以达到保证并发安全的效果。二.sync...
深入理解 synchronized 关键字
程序员cxuan的个人主页
06-02 2636
前言 synchronized 这个关键字的重要性不言而喻，几乎可以说是并发、多线程必须会问到的关键字了。synchronized 会涉及到锁、升级降级操作、锁的撤销、对象头等。所以理解 synchronized 非常重要，本篇文章就带你从 synchronized 的基本用法、再到 synchronized 的深入理解，对象头等，为你揭开 synchronized 的面纱。 浅析 synchronized synchronized 是 Java 并发模块非常重要的关键字，它是 Java 内建的一种同步机制
深入理解Synchronized关键字
Tech in Pieces
12-03 367
我们知道 这个关键字可以修饰代码块 可以修饰方法 可以修饰对象。 修饰对象，表示这个对象只能最多同时被一个线程获得（然后做想做的修改）。 修饰方法或者是代码块 表示这个代码块最多同时被一个线程执行。 但是 真正的答案是 这个关键字锁住的是对象。 其实，对于代码块 synchronized锁住的是括号里的对象，而不是代码。对于非static的synchronized方法，锁的就是对象本身也就是this。 synchronized(Sync.class)实现了全局锁的效果 static synchronized
深入理解Synchronized关键字底层原理及作用
xnmahahd的博客
09-26 158
深入理解Synchronized关键字底层原理及作用1 深入理解Synchronized关键字底层原理及作用2
深入理解Synchronized关键字底层原理及作用(二)
Imobama的博客
07-20 2934
Java 虚拟机中的同步(Synchronization)基于进入和退出管程(Monitor)对象实现， 无论是显式同步(有明确的 monitorenter 和 monitorexit 指令,即同步代码块)还是隐式同步(没有monitor指令,由ACC_SYNCHRONIZED标识,即同步方法)都是如此。在 Java 语言中，同步用的最多的地方可能是被 synchronized 修饰的同步方法。同...
深入理解Java中的synchronized关键字
weixin_74268571的博客
06-15 1496
synchronized的详细讲解和底层实现，以及synchronized的同步机制，synchronized的重入和synchronized的异常演示
Java并发编程——深入理解Synchronized 关键字
dreamchaser533534的博客
09-16 319
1.synchronized 关键字 1.1.说一说自己对于 synchronized 关键字的了解 synchronized关键字解决的是多个线程之间访问资源的同步性，synchronized关键字可以保证被它修饰的方法或者代码块在任意时刻只能有一个线程执行。 另外，在 Java 早期版本中，synchronized属于重量级锁，效率低下。 为什么呢？ 因为监视器锁（monitor）是依赖于底层的操作系统的Mutex Lock来实现的，Java 的线程是映射到操作系统的原生线程之上...
Java中的同步机制：深入理解synchronized关键字
10-28
synchronized关键字是Java中实现线程同步的基本工具，它通过锁定对象的monitor来控制对共享资源的并发访问。理解synchronized的工作原理和使用方式对于编写线程安全的Java程序至关重要。然而，由于其局限性，开发者...
深入理解Java中的synchronized关键字：同步机制与应用
07-05
在多线程编程中，确保线程安全是至关重要的。Java提供了多种机制来处理并发问题，其中synchronized...通过深入理解synchronized关键字，开发者可以更好地处理Java中的并发问题，构建出更加健壮和高效的多线程应用程序。
深入理解 synchronized 关键字的使用
synchronized 关键字可以用来修饰方法或代码块，保证在同一时间只有一个线程能够执行 synchronized 修饰的代码。 ## 1.2 synchronized 关键字的使用场景 synchronized 关键字通常用于以下场景： - 多个线程共享一...
基于vue框架的的汇生活家居商城的设计与实现bdjlq（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
10-29 1251
项目功能：商品分类,商品信息,用户。
（1）Java 编程基础概览：数据类型、常量、变量、标识符与运算符
码界领航的Cherry Yang的博客
10-28 1036
8 位，占1个字节，有符号的，范围 -128（-2^7）至 127（2^7-1）。32 位，占4个字节，范围 -2,147,483,648（-2^31）至 2,147,483,647（2^31 - 1）。Java 提供了六种数字类型，其中四个为整数类型，两个为浮点类型，还有字符类型，以及布尔型。16 位，占2个字节，范围 -32768（-2^15）至 32767（2^15 - 1）64 位，占8个字节，范围 -2^63 至 2^63 - 1。16 位 Unicode 字符，占 2 个字节。
java_方法递归调用
HHppGo的博客
10-27 507
简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变得简洁。
ssm智慧社区电子商务系统+vue
weixin_44832324的博客
10-28 1230
系统能否进行正常工作，功能模块能否实现，程序代码是否有错误，这些都需要通过系统测试来进行判断，测试是程序开发中必不可少的步骤，就算系统一步不差的被开发出来了，但进行测试时总能发现一个之前从没遇到过的问题[26]。在系统开发的整个过程当中都需要不断进行系统测试，根据经验发现，前期的一个小问题，将会酿成后期的一个大问题，所以越早发现，越早解决，才能保证后续的编码、测试和设计能够顺利进行。目前，系统测试所使用的方法主要是黑盒测试，系统测试的目的包括：根据客户的需求来设计用户界面；
Java复习24（PTA)
最新发布
2301_79272475的博客
10-30 295
Java复习24（PTA)：多种排序的book类*
Java多线程教程：深入理解synchronized关键字
onized代码块时，其他线程对“该对象”的该“synchronized方法”或者“synchronized代码块”的访问将被阻塞。这意味着如果线程A正在执行...理解和熟练运用synchronized关键字对于编写健壮的多线程应用程序至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值