13张图,深入理解Synchronized

开发 后端
本文带读者们由浅入深理解Synchronized,让读者们也能与面试官疯狂对线。

 前言

本文带读者们由浅入深理解Synchronized,让读者们也能与面试官疯狂对线。

在并发编程中Synchronized一直都是元老级的角色,Jdk 1.6以前大家都称呼它为重量级锁,相对于J U C包提供的Lock,它会显得笨重,不过随着Jdk 1.6对Synchronized进行各种优化后,Synchronized性能已经非常快了。

内容大纲

Synchronized使用方式

Synchronized是Java提供的同步关键字,在多线程场景下,对共享资源代码段进行读写操作(必须包含写操作,光读不会有线程安全问题,因为读操作天然具备线程安全特性),可能会出现线程安全问题,我们可以使用Synchronized锁定共享资源代码段,达到互斥(mutualexclusion)效果,保证线程安全。

共享资源代码段又称为临界区(critical section),保证临界区互斥,是指执行临界区(critical section)的只能有一个线程执行,其他线程阻塞等待,达到排队效果。

Synchronized的食用方式有三种

  •  修饰普通函数,监视器锁(monitor)便是对象实例(this)
  •  修饰静态静态函数,视器锁(monitor)便是对象的Class实例(每个对象只有一个Class实例)
  •  修饰代码块,监视器锁(monitor)是指定对象实例

普通函数

普通函数使用Synchronized的方式很简单,在访问权限修饰符与函数返回类型间加上Synchronized。

多线程场景下,thread与threadTwo两个线程执行incr函数,incr函数作为共享资源代码段被多线程读写操作,我们将它称为临界区,为了保证临界区互斥,使用Synchronized修饰incr函数即可。 

  1. public class SyncTest {  
  2.     private int j = 0;    
  3.     /**  
  4.      * 自增方法  
  5.      */  
  6.     public synchronized void incr(){  
  7.         //临界区代码--start  
  8.         for (int i = 0; i < 10000; i++) {  
  9.             j++;  
  10.         }  
  11.         //临界区代码--end  
  12.     }  
  13.     public int getJ() {  
  14.         return j;  
  15.     }  
  16. public class SyncMain {  
  17.     public static void main(String[] agrs) throws InterruptedException {  
  18.         SyncTest syncTest = new SyncTest();  
  19.         Thread thread = new Thread(() -> syncTest.incr());  
  20.         Thread threadTwo = new Thread(() -> syncTest.incr());  
  21.         thread.start();  
  22.         threadTwo.start();  
  23.         thread.join();  
  24.         threadTwo.join();  
  25.         //最终打印结果是20000,如果不使用synchronized修饰,就会导致线程安全问题,输出不确定结果  
  26.         System.out.println(syncTest.getJ());  
  27.     }  

代码十分简单,incr函数被synchronized修饰,函数逻辑是对j进行10000次累加,两个线程执行incr函数,最后输出j结果。

被synchronized修饰函数我们简称同步函数,线程执行称同步函数前,需要先获取监视器锁,简称锁,获取锁成功才能执行同步函数,同步函数执行完后,线程会释放锁并通知唤醒其他线程获取锁,获取锁失败「则阻塞并等待通知唤醒该线程重新获取锁」,同步函数会以this作为锁,即当前对象,以上面的代码段为例就是syncTest对象。

  •  线程thread执行syncTest.incr()前
  •  线程thread获取锁成功
  •  线程threadTwo执行syncTest.incr()前
  •  线程threadTwo获取锁失败
  •  线程threadTwo阻塞并等待唤醒
  •  线程thread执行完syncTest.incr(),j累积到10000
  •  线程thread释放锁,通知唤醒threadTwo线程获取锁
  •  线程threadTwo获取锁成功
  •  线程threadTwo执行完syncTest.incr(),j累积到20000
  •  线程threadTwo释放锁

静态函数

静态函数顾名思义,就是静态的函数,它使用Synchronized的方式与普通函数一致,唯一的区别是锁的对象不再是this,而是Class对象。

多线程执行Synchronized修饰静态函数代码段如下。 

  1. public class SyncTest {  
  2.     private static int j = 0;      
  3.     /**  
  4.      * 自增方法  
  5.      */  
  6.     public static synchronized void incr(){  
  7.         //临界区代码--start  
  8.         for (int i = 0; i < 10000; i++) {  
  9.             j++;  
  10.         }  
  11.         //临界区代码--end  
  12.     }  
  13.     public static int getJ() {  
  14.         return j;  
  15.     }  
  16.  
  17. public class SyncMain {  
  18.     public static void main(String[] agrs) throws InterruptedException {  
  19.         Thread thread = new Thread(() -> SyncTest.incr());  
  20.         Thread threadTwo = new Thread(() -> SyncTest.incr());  
  21.         thread.start();  
  22.         threadTwo.start();  
  23.         thread.join();  
  24.         threadTwo.join();  
  25.         //最终打印结果是20000,如果不使用synchronized修饰,就会导致线程安全问题,输出不确定结果  
  26.         System.out.println(SyncTest.getJ());  
  27.     }  

Java的静态资源可以直接通过类名调用,静态资源不属于任何实例对象,它只属于Class对象,每个Class在J V M中只有唯一的一个Class对象,所以同步静态函数会以Class对象作为锁,后续获取锁、释放锁流程都一致。

代码块

前面介绍的普通函数与静态函数粒度都比较大,以整个函数为范围锁定,现在想把范围缩小、灵活配置,就需要使用代码块了,使用{}符号定义范围给Synchronized修饰。

下面代码中定义了syncDbData函数,syncDbData是一个伪同步数据的函数,耗时2秒,并且逻辑不涉及共享资源读写操作(非临界区),另外还有两个函数incr与incrTwo,都是在自增逻辑前执行了syncDbData函数,只是使用Synchronized的姿势不同,一个是修饰在函数上,另一个是修饰在代码块上。 

  1. public class SyncTest {  
  2.     private static int j = 0 
  3.     /**  
  4.      * 同步库数据,比较耗时,代码资源不涉及共享资源读写操作。  
  5.      */  
  6.     public void syncDbData() {  
  7.         System.out.println("db数据开始同步------------");  
  8.         try {  
  9.             //同步时间需要2秒  
  10.             Thread.sleep(2000);  
  11.         } catch (InterruptedException e) {  
  12.             e.printStackTrace();  
  13.         }  
  14.         System.out.println("db数据开始同步完成------------");  
  15.     }  
  16.     //自增方法  
  17.     public synchronized void incr() {  
  18.         //start--临界区代码  
  19.         //同步库数据  
  20.         syncDbData();  
  21.         for (int i = 0; i < 10000; i++) {  
  22.             j++;  
  23.         }  
  24.         //end--临界区代码  
  25.     }  
  26.     //自增方法  
  27.     public void incrTwo() {  
  28.         //同步库数据  
  29.         syncDbData();  
  30.         synchronized (this) {  
  31.             //start--临界区代码  
  32.             for (int i = 0; i < 10000; i++) {  
  33.                 j++;  
  34.             }  
  35.             //end--临界区代码  
  36.         }  
  37.     }  
  38.     public int getJ() {  
  39.         return j;  
  40.     }  
  41.  
  42. public class SyncMain {  
  43.     public static void main(String[] agrs) throws InterruptedException {  
  44.         //incr同步方法执行  
  45.         SyncTest syncTest = new SyncTest();  
  46.         Thread thread = new Thread(() -> syncTest.incr());  
  47.         Thread threadTwo = new Thread(() -> syncTest.incr());  
  48.         thread.start();  
  49.         threadTwo.start();  
  50.         thread.join();  
  51.         threadTwo.join();  
  52.         //最终打印结果是20000  
  53.         System.out.println(syncTest.getJ());  
  54.         //incrTwo同步块执行  
  55.         thread = new Thread(() -> syncTest.incrTwo());  
  56.         threadTwo = new Thread(() -> syncTest.incrTwo());  
  57.         thread.start();  
  58.         threadTwo.start();  
  59.         thread.join();  
  60.         threadTwo.join();  
  61.         //最终打印结果是40000  
  62.         System.out.println(syncTest.getJ());  
  63.     }  

先看看incr同步方法执行,流程和前面没区别,只是Synchronized锁定的范围太大,把syncDbData()也纳入临界区中,多线程场景执行,会有性能上的浪费,因为syncDbData()完全可以让多线程并行或并发执行。

我们通过代码块的方式,来缩小范围,定义正确的临界区,提升性能,目光转到incrTwo同步块执行,incrTwo函数使用修饰代码块的方式同步,只对自增代码段进行锁定。

代码块同步方式除了灵活控制范围外,还能做线程间的协同工作,因为Synchronized ()括号中能接收任何对象作为锁,所以可以通过Object的wait、notify、notifyAll等函数,做多线程间的通信协同(本文不对线程通信协同做展开,主角是Synchronized,而且也不推荐去用这些方法,因为LockSupport工具类会是更好的选择)。

  •  wait:当前线程暂停,释放锁
  •  notify:释放锁,唤醒调用了wait的线程(如果有多个随机唤醒一个)
  •  notifyAll:释放锁,唤醒调用了wait的所有线程

Synchronized原理 

  1. public class SyncTest {  
  2.     private static int j = 0 
  3.     /**  
  4.      * 同步库数据,比较耗时,代码资源不涉及共享资源读写操作。  
  5.      */  
  6.     public void syncDbData() {  
  7.         System.out.println("db数据开始同步------------");  
  8.         try {  
  9.             //同步时间需要2秒  
  10.             Thread.sleep(2000);  
  11.         } catch (InterruptedException e) {  
  12.             e.printStackTrace();  
  13.         }  
  14.         System.out.println("db数据开始同步完成------------");  
  15.     }  
  16.     //自增方法  
  17.     public synchronized void incr() {  
  18.         //start--临界区代码  
  19.         //同步库数据  
  20.         syncDbData();  
  21.         for (int i = 0; i < 10000; i++) {  
  22.             j++;  
  23.         }  
  24.         //end--临界区代码  
  25.     }  
  26.     //自增方法  
  27.     public void incrTwo() {  
  28.         //同步库数据  
  29.         syncDbData();  
  30.         synchronized (this) {  
  31.             //start--临界区代码  
  32.             for (int i = 0; i < 10000; i++) {  
  33.                 j++;  
  34.             }  
  35.             //end--临界区代码  
  36.         }  
  37.     }  
  38.     public int getJ() {  
  39.         return j;  
  40.     }  
  41. }  

为了探究Synchronized原理,我们对上面的代码进行反编译,输出反编译后结果,看看底层是如何实现的(环境Java 11、win 10系统)。 

  1. 只截取了incr与incrTwo函数内容          
  2.  public synchronized void incr();  
  3.    Code:  
  4.       0: aload_0                                          
  5.       1: invokevirtual #11                 // Method syncDbData:()V   
  6.       4: iconst_0                        
  7.       5: istore_1                        
  8.       6: iload_1                                    
  9.       7: sipush        10000            
  10.      10: if_icmpge     27  
  11.      13: getstatic     #12                 // Field j:I  
  12.      16: iconst_1  
  13.      17: iadd  
  14.      18: putstatic     #12                 // Field j:I  
  15.      21: iinc          1, 1  
  16.      24: goto          6  
  17.      27: return   
  18.  public void incrTwo();      
  19.    Code:  
  20.       0: aload_0  
  21.       1: invokevirtual #11                 // Method syncDbData:()V  
  22.       4: aload_0  
  23.       5: dup  
  24.       6: astore_1  
  25.       7: monitorenter                     //获取锁  
  26.       8: iconst_0  
  27.       9: istore_2  
  28.      10: iload_2  
  29.      11: sipush        10000  
  30.      14: if_icmpge     31  
  31.      17: getstatic     #12                 // Field j:I  
  32.      20: iconst_1  
  33.      21: iadd  
  34.      22: putstatic     #12                 // Field j:I  
  35.      25: iinc          2, 1  
  36.      28: goto          10  
  37.      31: aload_1  
  38.      32: monitorexit                      //正常退出释放锁   
  39.      33: goto          41  
  40.      36: astore_3  
  41.      37: aload_1  
  42.      38: monitorexit                      //异步退出释放锁    
  43.      39: aload_3  
  44.      40: athrow  
  45.      41: return 

ps:对上面指令感兴趣的读者,可以百度或google一下“JVM 虚拟机字节码指令表”

先看incrTwo函数,incrTwo是代码块方式同步,在反编译后的结果中,我们发现存在monitorenter与monitorexit指令(获取锁、释放锁)。

monitorenter指令插入到同步代码块的开始位置,monitorexit指令插入到同步代码块的结束位置,J V M需要保证每一个 monitorenter都有monitorexit与之对应。

任何对象都有一个监视器锁(monitor)关联,线程执行monitorenter指令时尝试获取monitor的所有权。

  •  如果monitor的进入数为0,则该线程进入monitor,然后将进入数设置为1,该线程为monitor的所有者
  •  如果线程已经占有该monitor,重新进入,则monitor的进入数加1
  •  线程执行monitorexit,monitor的进入数-1,执行过多少次monitorenter,最终要执行对应次数的monitorexit
  •  如果其他线程已经占用monitor,则该线程进入阻塞状态,直到monitor的进入数为0,再重新尝试获取monitor的所有权

回过头看incr函数,incr是普通函数方式同步,虽然在反编译后的结果中没有看到monitorenter与monitorexit指令,但是实际执行的流程与incrTwo函数一样,通过monitor来执行,只不过它是一种隐式的方式来实现,最后放一张流程图。

Synchronized优化

Jdk 1.5以后对Synchronized关键字做了各种的优化,经过优化后Synchronized已经变得原来越快了,这也是为什么官方建议使用Synchronized的原因,具体的优化点如下。

  •  锁粗化
  •  锁消除
  •  锁升级

锁粗化

互斥的临界区范围应该尽可能小,这样做的目的是为了使同步的操作数量尽可能缩小,缩短阻塞时间,如果存在锁竞争,那么等待锁的线程也能尽快拿到锁。

但是加锁解锁也需要消耗资源,如果存在一系列的连续加锁解锁操作,可能会导致不必要的性能损耗,锁粗化就是将「多个连续的加锁、解锁操作连接在一起」,扩展成一个范围更大的锁,避免频繁的加锁解锁操作。

J V M会检测到一连串的操作都对同一个对象加锁(for循环10000次执行j++,没有锁粗化就要进行10000次加锁/解锁),此时J V M就会将加锁的范围粗化到这一连串操作的外部(比如for循环体外),使得这一连串操作只需要加一次锁即可。

锁消除

Java虚拟机在JIT编译时(可以简单理解为当某段代码即将第一次被执行时进行编译,又称即时编译),通过对运行上下文的扫描,经过逃逸分析(对象在函数中被使用,也可能被外部函数所引用,称为函数逃逸),去除不可能存在共享资源竞争的锁,通过这种方式消除没有必要的锁,可以节省毫无意义的时间消耗。

代码中使用Object作为锁,但是Object对象的生命周期只在incrFour()函数中,并不会被其他线程所访问到,所以在J I T编译阶段就会被优化掉(此处的Object属于没有逃逸的对象)。

锁升级

Java中每个对象都拥有对象头,对象头由Mark World 、指向类的指针、以及数组长度三部分组成,本文,我们只需要关心Mark World 即可,Mark World  记录了对象的HashCode、分代年龄和锁标志位信息。

Mark World简化结构

锁状态 存储内容 锁标记
无锁 对象的hashCode、对象分代年龄、是否是偏向锁(0) 01
偏向锁 偏向线程ID、偏向时间戳、对象分代年龄、是否是偏向锁(1) 01
轻量级锁 指向栈中锁记录的指针 00
重量级锁 指向互斥量(重量级锁)的指针 10

读者们只需知道,锁的升级变化,体现在锁对象的对象头Mark World部分,也就是说Mark World的内容会随着锁升级而改变。

Java1.5以后为了减少获取锁和释放锁带来的性能消耗,引入了偏向锁和轻量级锁,Synchronized的升级顺序是 「无锁-->偏向锁-->轻量级锁-->重量级锁,只会升级不会降级」

偏向锁

在大多数情况下,锁总是由同一线程多次获得,不存在多线程竞争,所以出现了偏向锁,其目标就是在只有一个线程执行同步代码块时,降低获取锁带来的消耗,提高性能(可以通过J V M参数关闭偏向锁:-XX:-UseBiasedLocking=false,关闭之后程序默认会进入轻量级锁状态)。

线程执行同步代码或方法前,线程只需要判断对象头的Mark Word中线程ID与当前线程ID是否一致,如果一致直接执行同步代码或方法,具体流程如下

  •  无锁状态,存储内容「是否为偏向锁(0)」,锁标识位01
    •   CAS设置当前线程ID到Mark Word存储内容中
    •   是否为偏向锁0 => 是否为偏向锁1
    •    执行同步代码或方法
  •  偏向锁状态,存储内容「是否为偏向锁(1)、线程ID」,锁标识位01
    •    对比线程ID是否一致,如果一致执行同步代码或方法,否则进入下面的流程
    •    如果不一致,CAS将Mark Word的线程ID设置为当前线程ID,设置成功,执行同步代码或方法,否则进入下面的流程
    •    CAS设置失败,证明存在多线程竞争情况,触发撤销偏向锁,当到达全局安全点,偏向锁的线程被挂起,偏向锁升级为轻量级锁,然后在安全点的位置恢复继续往下执行。

轻量级锁

轻量级锁考虑的是竞争锁对象的线程不多,持有锁时间也不长的场景。因为阻塞线程需要C P U从用户态转到内核态,代价较大,如果刚刚阻塞不久这个锁就被释放了,那这个代价就有点得不偿失,所以干脆不阻塞这个线程,让它自旋一段时间等待锁释放。

当前线程持有的锁是偏向锁的时候,被另外的线程所访问,偏向锁就会升级为轻量级锁,其他线程会通过自旋的形式尝试获取锁,不会阻塞,从而提高性能。轻量级锁的获取主要有两种情况:① 当关闭偏向锁功能时;② 多个线程竞争偏向锁导致偏向锁升级为轻量级锁。

  •  无锁状态,存储内容「是否为偏向锁(0)」,锁标识位01
    •   关闭偏向锁功能时
    •   CAS设置当前线程栈中锁记录的指针到Mark Word存储内容
    •   锁标识位设置为00
    •   执行同步代码或方法
    •   释放锁时,还原来Mark Word内容
  •  轻量级锁状态,存储内容「线程栈中锁记录的指针」,锁标识位00(存储内容的线程是指"持有轻量级锁的线程")
    •   CAS设置当前线程栈中锁记录的指针到Mark Word存储内容,设置成功获取轻量级锁,执行同步块代码或方法,否则执行下面的逻辑
    •   设置失败,证明多线程存在一定竞争,线程自旋上一步的操作,自旋一定次数后还是失败,轻量级锁升级为重量级锁
    •    Mark Word存储内容替换成重量级锁指针,锁标记位10

重量级锁

轻量级锁膨胀之后,就升级为重量级锁,重量级锁是依赖操作系统的MutexLock(互斥锁)来实现的,需要从用户态转到内核态,这个成本非常高,这就是为什么Java1.6之前Synchronized效率低的原因。

升级为重量级锁时,锁标志位的状态值变为10,此时Mark Word中存储内容的是重量级锁的指针,等待锁的线程都会进入阻塞状态,下面是简化版的锁升级过程。

 

 

责任编辑:庞桂玉 来源: Java编程
相关推荐

2021-04-25 10:45:59

Docker架构Job

2020-11-13 08:42:24

Synchronize

2022-07-04 08:01:01

锁优化Java虚拟机

2019-07-24 08:49:36

Docker容器镜像

2010-06-01 15:25:27

JavaCLASSPATH

2020-07-21 08:26:08

SpringSecurity过滤器

2016-12-08 15:36:59

HashMap数据结构hash函数

2019-06-25 10:32:19

UDP编程通信

2017-08-15 13:05:58

Serverless架构开发运维

2017-01-10 08:48:21

2024-02-21 21:14:20

编程语言开发Golang

2020-09-23 10:00:26

Redis数据库命令

2023-10-19 11:12:15

Netty代码

2013-09-22 14:57:19

AtWood

2009-09-25 09:14:35

Hibernate日志

2021-02-17 11:25:33

前端JavaScriptthis

2022-08-02 08:32:21

Spring项目网关

2022-09-04 17:53:20

Prometheus开源

2023-09-26 08:01:46

消费者TopicRocketMQ

2020-11-13 16:40:05

RocketMQ延迟消息架构
点赞
收藏

51CTO技术栈公众号