Java之戳中痛点之 synchronized 深度解析
点击上方“方志朋”,选择“设为星标”
回复”666“获取新整理的面试文章
作者:Json_wangqiang
cnblogs.com/JsonShare/p/11433302.html
概览:
简介:作用、地位、不控制并发的影响
用法:对象锁和类锁
多线程访问同步方法的7种情况
性质:可重入、不可中断
原理:加解锁原理、可重入原理、可见性原理
缺陷:效率低、不够灵活、无法预判是否成功获取到锁
如何选择Lock或Synchronized
如何提高性能、JVM如何决定哪个线程获取锁
总结
后续会有代码演示,测试环境 JDK8、IDEA
一、简介
1、作用
能够保证在同一时刻最多只有一个线程执行该代码,以保证并发安全的效果。
2、地位
Synchronized是Java关键字,Java原生支持
最基本的互斥同步手段
并发编程的元老级别
3、不控制并发的影响
测试:两个线程同时a++,猜一下结果
package cn.jsonshare.java.base.synchronizedtest;/*** 不使用synchronized,两个线程同时a++** @author JSON*/
public class SynchronizedTest1 implements Runnable{static SynchronizedTest1 st = new SynchronizedTest1();static int a = 0;/*** 不使用synchronized,两个线程同时a++*/public static void main(String[] args) throws Exception{Thread t1 = new Thread(st);Thread t2 = new Thread(st);t1.start();t2.start();t1.join();t2.join();System.out.println(a);}@Overridepublic void run(){for(int i=0; i<10000; i++){a++;}}
}
预期是20000,但多次执行的结果都小于20000
10108
11526
10736
...
二、用法:对象锁和类锁
1、对象锁
代码块形式:手动指定锁对象
方法锁形式:synchronized修饰方法,锁对象默认为this
package cn.jsonshare.java.base.synchronizedtest;/*** 对象锁实例: 代码块形式** @author JSON*/
public class SynchronizedTest2 implements Runnable{static SynchronizedTest2 st = new SynchronizedTest2();public static void main(String[] args) {Thread t1 = new Thread(st);Thread t2 = new Thread(st);t1.start();t2.start();while(t1.isAlive() || t2.isAlive()){}System.out.println("run over");}@Overridepublic void run(){synchronized (this){System.out.println("开始执行:" + Thread.currentThread().getName());try {// 模拟执行内容Thread.sleep(3000);}catch (Exception e){e.printStackTrace();}System.out.println("执行结束:" + Thread.currentThread().getName());}}
}
package cn.jsonshare.java.base.synchronizedtest;/*** 对象锁实例:synchronized方法* @author JSON*/
public class SynchronizedTest3 implements Runnable{static SynchronizedTest3 st = new SynchronizedTest3();public static void main(String[] args) throws Exception{Thread t1 = new Thread(st);Thread t2 = new Thread(st);t1.start();t2.start();t1.join();t2.join();System.out.println("run over");}@Overridepublic void run(){method();}public synchronized void method(){System.out.println("开始执行:" + Thread.currentThread().getName());try {// 模拟执行内容Thread.sleep(3000);}catch (Exception e){e.printStackTrace();}System.out.println("执行结束:" + Thread.currentThread().getName());}
}
结果:
开始执行:Thread-0
执行结束:Thread-0
开始执行:Thread-1
执行结束:Thread-1
run over
2、类锁
概念:Java类可能有多个对象,但只有一个Class对象
本质:所谓的类锁,不过是Class对象的锁而已
用法和效果:类锁只能在同一时刻被一个对象拥有
形式1:synchronized加载static方法上
形式2:synchronized(*.class)代码块
package cn.jsonshare.java.base.synchronizedtest;/*** 类锁:synchronized加载static方法上** @author JSON*/
public class SynchronizedTest4 implements Runnable{static SynchronizedTest4 st1 = new SynchronizedTest4();static SynchronizedTest4 st2 = new SynchronizedTest4();public static void main(String[] args) throws Exception{Thread t1 = new Thread(st1);Thread t2 = new Thread(st2);t1.start();t2.start();t1.join();t2.join();System.out.println("run over");}@Overridepublic void run(){method();}public static synchronized void method(){System.out.println("开始执行:" + Thread.currentThread().getName());try {// 模拟执行内容Thread.sleep(3000);}catch (Exception e){e.printStackTrace();}System.out.println("执行结束:" + Thread.currentThread().getName());}
}
package cn.jsonshare.java.base.synchronizedtest;/*** 类锁:synchronized(*.class)代码块** @author JSON*/
public class SynchronizedTest5 implements Runnable{static SynchronizedTest4 st1 = new SynchronizedTest4();static SynchronizedTest4 st2 = new SynchronizedTest4();public static void main(String[] args) throws Exception{Thread t1 = new Thread(st1);Thread t2 = new Thread(st2);t1.start();t2.start();t1.join();t2.join();System.out.println("run over");}@Overridepublic void run(){method();}public void method(){synchronized(SynchronizedTest5.class){System.out.println("开始执行:" + Thread.currentThread().getName());try {// 模拟执行内容Thread.sleep(3000);}catch (Exception e){e.printStackTrace();}System.out.println("执行结束:" + Thread.currentThread().getName());}}
}
结果:
开始执行:Thread-0
执行结束:Thread-0
开始执行:Thread-1
执行结束:Thread-1
run over
Java知音公众号内回复“面试题聚合”,送你一份面试题宝典
三、多线程访问同步方法的7种情况
两个线程同时访问一个对象的相同的synchronized方法
两个线程同时访问两个对象的相同的synchronized方法
两个线程同时访问两个对象的相同的static的synchronized方法
两个线程同时访问同一对象的synchronized方法与非synchronized方法
两个线程访问同一对象的不同的synchronized方法
两个线程同时访问同一对象的static的synchronized方法与非static的synchronized方法
方法抛出异常后,会释放锁吗
仔细看下面示例代码结果输出的结果,注意输出时间间隔,来预测结论
场景1:
package cn.jsonshare.java.base.synchronizedtest;/*** 两个线程同时访问一个对象的相同的synchronized方法** @author JSON*/
public class SynchronizedScene1 implements Runnable{static SynchronizedScene1 ss = new SynchronizedScene1();public static void main(String[] args) throws Exception{Thread t1 = new Thread(ss);Thread t2 = new Thread(ss);t1.start();t2.start();t1.join();t2.join();System.out.println("run over");}@Overridepublic void run(){method();}public synchronized void method(){System.out.println("开始执行:" + Thread.currentThread().getName());try {// 模拟执行内容Thread.sleep(3000);}catch (Exception e){e.printStackTrace();}System.out.println("执行结束:" + Thread.currentThread().getName());}
}
场景2:
package cn.jsonshare.java.base.synchronizedtest;/*** 两个线程同时访问两个对象的相同的synchronized方法** @author JSON*/
public class SynchronizedScene2 implements Runnable{static SynchronizedScene2 ss1 = new SynchronizedScene2();static SynchronizedScene2 ss2 = new SynchronizedScene2();public static void main(String[] args) throws Exception{Thread t1 = new Thread(ss1);Thread t2 = new Thread(ss2);t1.start();t2.start();t1.join();t2.join();System.out.println("run over");}@Overridepublic void run(){method();}public synchronized void method(){System.out.println("开始执行:" + Thread.currentThread().getName());try {// 模拟执行内容Thread.sleep(3000);}catch (Exception e){e.printStackTrace();}System.out.println("执行结束:" + Thread.currentThread().getName());}
}
场景3:
package cn.jsonshare.java.base.synchronizedtest;/*** 两个线程同时访问两个对象的相同的static的synchronized方法** @author JSON*/
public class SynchronizedScene3 implements Runnable{static SynchronizedScene3 ss1 = new SynchronizedScene3();static SynchronizedScene3 ss2 = new SynchronizedScene3();public static void main(String[] args) throws Exception{Thread t1 = new Thread(ss1);Thread t2 = new Thread(ss2);t1.start();t2.start();t1.join();t2.join();System.out.println("run over");}@Overridepublic void run(){method();}public synchronized static void method(){System.out.println("开始执行:" + Thread.currentThread().getName());try {// 模拟执行内容Thread.sleep(3000);}catch (Exception e){e.printStackTrace();}System.out.println("执行结束:" + Thread.currentThread().getName());}
}
场景4:
package cn.jsonshare.java.base.synchronizedtest;/*** 两个线程同时访问同一对象的synchronized方法与非synchronized方法** @author JSON*/
public class SynchronizedScene4 implements Runnable{static SynchronizedScene4 ss1 = new SynchronizedScene4();public static void main(String[] args) throws Exception{Thread t1 = new Thread(ss1);Thread t2 = new Thread(ss1);t1.start();t2.start();t1.join();t2.join();System.out.println("run over");}@Overridepublic void run(){// 模拟两个线程同时访问 synchronized方法与非synchronized方法if(Thread.currentThread().getName().equals("Thread-0")){method1();}else{method2();}}public void method1(){System.out.println("method1开始执行:" + Thread.currentThread().getName());try {// 模拟执行内容Thread.sleep(3000);}catch (Exception e){e.printStackTrace();}System.out.println("method1执行结束:" + Thread.currentThread().getName());}public synchronized void method2(){System.out.println("method2开始执行:" + Thread.currentThread().getName());try {// 模拟执行内容Thread.sleep(3000);}catch (Exception e){e.printStackTrace();}System.out.println("method2执行结束:" + Thread.currentThread().getName());}
}
场景5:
package cn.jsonshare.java.base.synchronizedtest;/*** 两个线程访问同一对象的不同的synchronized方法** @author JSON*/
public class SynchronizedScene5 implements Runnable{static SynchronizedScene5 ss1 = new SynchronizedScene5();public static void main(String[] args) throws Exception{Thread t1 = new Thread(ss1);Thread t2 = new Thread(ss1);t1.start();t2.start();t1.join();t2.join();System.out.println("run over");}@Overridepublic void run(){// 模拟两个线程同时访问不同的synchronized方法if(Thread.currentThread().getName().equals("Thread-0")){method1();}else{method2();}}public synchronized void method1(){System.out.println("method1开始执行:" + Thread.currentThread().getName());try {// 模拟执行内容Thread.sleep(3000);}catch (Exception e){e.printStackTrace();}System.out.println("method1执行结束:" + Thread.currentThread().getName());}public synchronized void method2(){System.out.println("method2开始执行:" + Thread.currentThread().getName());try {// 模拟执行内容Thread.sleep(3000);}catch (Exception e){e.printStackTrace();}System.out.println("method2执行结束:" + Thread.currentThread().getName());}
}
场景6:
package cn.jsonshare.java.base.synchronizedtest;/*** 两个线程同时访问同一对象的static的synchronized方法与非static的synchronized方法** @author JSON*/
public class SynchronizedScene6 implements Runnable{static SynchronizedScene6 ss1 = new SynchronizedScene6();public static void main(String[] args) throws Exception{Thread t1 = new Thread(ss1);Thread t2 = new Thread(ss1);t1.start();t2.start();t1.join();t2.join();System.out.println("run over");}@Overridepublic void run(){// 模拟两个线程同时访问static的synchronized方法与非static的synchronized方法if(Thread.currentThread().getName().equals("Thread-0")){method1();}else{method2();}}public static synchronized void method1(){System.out.println("method1开始执行:" + Thread.currentThread().getName());try {// 模拟执行内容Thread.sleep(3000);}catch (Exception e){e.printStackTrace();}System.out.println("method1执行结束:" + Thread.currentThread().getName());}public synchronized void method2(){System.out.println("method2开始执行:" + Thread.currentThread().getName());try {// 模拟执行内容Thread.sleep(3000);}catch (Exception e){e.printStackTrace();}System.out.println("method2执行结束:" + Thread.currentThread().getName());}
}
场景7:
package cn.jsonshare.java.base.synchronizedtest;/*** 方法抛出异常后,会释放锁吗** @author JSON*/
public class SynchronizedScene7 implements Runnable{static SynchronizedScene7 ss1 = new SynchronizedScene7();public static void main(String[] args) throws Exception{Thread t1 = new Thread(ss1);Thread t2 = new Thread(ss1);t1.start();t2.start();t1.join();t2.join();System.out.println("run over");}@Overridepublic void run(){method1();}public synchronized void method1(){System.out.println("method1开始执行:" + Thread.currentThread().getName());try {// 模拟执行内容Thread.sleep(3000);}catch (Exception e){e.printStackTrace();}// 模拟异常throw new RuntimeException();//System.out.println("method1执行结束:" + Thread.currentThread().getName());}
}
Java知音公众号内回复“面试题聚合”,送你一份面试题宝典
总结:
1、两个线程同时访问一个对象的相同的synchronized方法
同一实例拥有同一把锁,其他线程必然等待,顺序执行
2、两个线程同时访问两个对象的相同的synchronized方法
不同的实例拥有的锁是不同的,所以不影响,并行执行
3、两个线程同时访问两个对象的相同的static的synchronized方法
静态同步方法,是类锁,所有实例是同一把锁,其他线程必然等待,顺序执行
4、两个线程同时访问同一对象的synchronized方法与非synchronized方法
非synchronized方法不受影响,并行执行
5、两个线程访问同一对象的不同的synchronized方法
同一实例拥有同一把锁,所以顺序执行(说明:锁的是this对象==同一把锁)
6、两个线程同时访问同一对象的static的synchronized方法与非static的synchronized方法
static同步方法是类锁,非static是对象锁,原理上是不同的锁,所以不受影响,并行执行
7、方法抛出异常后,会释放锁吗
会自动释放锁,这里区别Lock,Lock需要显示的释放锁
3个核心思想:
一把锁只能同时被一个线程获取,没有拿到锁的线程必须等待(对应1、5的情景)
每个实例都对应有自己的一把锁,不同的实例之间互不影响;例外:锁对象是*.class以及synchronized被static修饰的时候,所有对象共用同一把锁(对应2、3、4、6情景)
无论是方法正常执行完毕还是方法抛出异常,都会释放锁(对应7情景)
补充:
问题:目前进入到被synchronized修饰的方法,这个方法里边调用了非synchronized方法,是线程安全的吗?
package cn.jsonshare.java.base.synchronizedtest;/*** 目前进入到被synchronized修饰的方法,这个方法里边调用了非synchronized方法,是线程安全的吗?** @author JSON*/
public class SynchronizedScene8 {public static void main(String[] args) {new Thread(() -> {method1();}).start();new Thread(() -> {method1();}).start();}public static synchronized void method1() {method2();}private static void method2() {System.out.println(Thread.currentThread().getName() + "进入非Synchronized方法");try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "结束非Synchronized方法");}
}
结论:这样是线程安全的
四、性质
1、可重入
指的是同一线程的外层函数获取锁之后,内层函数可以直接再次获取该锁
Java典型的可重入锁:synchronized、ReentrantLock
好处:避免死锁,提升封装性
粒度:线程而非调用
情况1:证明同一方法是可重入的
情况2:证明可重入不要求是同一方法
情况3:证明可重入不要求是同一类中的
2、不可中断
一旦这个锁被别的线程获取了,如果我现在想获得,我只能选择等待或者阻塞,直到别的线程释放这个锁,如果别的线程永远不释放锁,那么我只能永远的等待下去。
相比之下,Lock类可以拥有中断的能力,第一点:如果我觉得我等待的时间太长了,有权中断现在已经获取到锁的线程执行;第二点:如果我觉得我等待的时间太长了不想再等了,也可以退出。
五、原理
1、加解锁原理(现象、时机、深入JVM看字节码)
现象:每一个类的实例对应一把锁,每一个synchronized方法都必须首先获得调用该方法的类的实例的锁,方能执行,否则就会阻塞,方法执行完成或者抛出异常,锁被释放,被阻塞线程才能获取到该锁,执行。
获取和释放锁的时机:内置锁或监视器锁
package cn.jsonshare.java.base.synchronizedtest;import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;/*** method1 等价于 method2** @author JSON* @date 2019-08-29*/
public class SynchronizedToLock1 {Lock lock = new ReentrantLock();public synchronized void method1(){System.out.println("执行method1");}public void method2(){lock.lock();try {System.out.println("执行method2");}catch (Exception e){e.printStackTrace();}finally {lock.unlock();}}public static void main(String[] args) {SynchronizedToLock1 sl = new SynchronizedToLock1();// method1 等价于 method2sl.method1();sl.method2();}
}
深入JVM看字节码:
...
monitorenter指令
...
monitorexit指令
...
2、可重入原理(加锁次数计数器)
JVM负责跟踪对象被加锁的次数
线程第一次给对象加锁的时候,计数变为1,每当这个相同的线程在此对象上再次获得锁时,计数会递增
每当任务离开时,计数递减,当计数为0的时候,锁被完全释放
3、可见性原理(内存模型)
Java内存模型
线程A向线程B发送数据的过程(JMM控制)
synchronized关键字实现可见性:
被synchronized修饰,那么执行完成后,对对象所做的任何修改都要在释放锁之前,都要从线程内存写入到主内存,所以主内存中的数据是最新的。
六、缺陷
1、效率低
1)、锁的释放情况少(线程执行完成或者异常情况释放)
2)、试图获得锁时不能设定超时(只能等待)
3)、不能中断一个正在试图获得锁的线程(不能中断)
2、不够灵活
加锁和释放的时机比较单一,每个锁仅有单一的条件(某个对象),可能是不够的
比如:读写锁更灵活
3、无法预判是否成功获取到锁
七、常见问题
1、synchronized关键字注意点:
锁对象不能为空
作用域不宜过大
避免死锁
2、如何选择Lock和synchronized关键字?
总结建议(优先避免出错的原则):
如果可以的话,尽量优先使用java.util.concurrent各种类(不需要考虑同步工作,不容易出错)
优先使用synchronized,这样可以减少编写代码的量,从而可以减少出错率
若用到Lock或Condition独有的特性,才使用Lock或Condition
八、总结
一句话总结synchronized:
JVM会自动通过使用monitor来加锁和解锁,保证了同一时刻只有一个线程可以执行指定的代码,从而保证线程安全,同时具有可重入和不可中断的特性。
热门内容:数据库链接池终于搞对了,这次直接从100ms优化到3ms!
被面试官问懵B了,十亿级数据ES搜索怎么优化?
骚操作 | 不重启 JVM,替换掉已经加载的类,偷天换日?分布式锁用 Redis 还是 Zookeeper?写那么多年Java,还不知道啥是Java agent 的必须看一下!
科普|什么是负载均衡(Load balancing)最近面试BAT,整理一份面试资料《Java面试BAT通关手册》,覆盖了Java核心技术、JVM、Java并发、SSM、微服务、数据库、数据结构等等。获取方式:点“在看”,关注公众号并回复 666 领取,更多内容陆续奉上。
明天见(。・ω・。)ノ♡
Java之戳中痛点之 synchronized 深度解析相关推荐
- Java之戳中痛点之synchronized 深度解析【云图智联】
概览: 简介:作用.地位.不控制并发的影响 用法:对象锁和类锁 多线程访问同步方法的7种情况 性质:可重入.不可中断 原理:加解锁原理.可重入原理.可见性原理 缺陷:效率低.不够灵活.无法预判是否成功 ...
- Java之戳中痛点 - (4)i++ 和 ++i 探究原理
先看一个例子: package com.test;public class AutoIncrement {public static void main(String[] args) {int a=7 ...
- Java之戳中痛点 - (5)switch语句break不能忘以及default不同位置的用法
先看一段代码: public class Test{ public static void main(String[] args){ System.out.println("2 = &quo ...
- Java高并发之魂:synchronized深度解析
本文整理自慕课网的讲师悟空老师,教学地址:http://www.imooc.com/learn/1086 文章目录 一.synchronized简介 1 synchronized作用 1.1 官方翻译 ...
- echo 框架中的 middleware 设计深度解析
关注我,了解更多源码设计及实现细节... echo 框架中的 middleware 设计深度解析 " echo web 框架是 go 语言开发的一种高性能,可扩展,轻量级的web框架.几行代 ...
- java中对JVM的深度解析、调优工具、垃圾回收
jdk自带的JVM调优工具 jvm监控分析工具一般分为两类,一种是jdk自带的工具,一种是第三方的分析工具.jdk自带工具一般在jdk bin目录下面,以exe的形式直接点击就可以使用,其中包含分析工 ...
- 一文详解java中对JVM的深度解析、调优工具、垃圾回收
2019独角兽企业重金招聘Python工程师标准>>> jvm监控分析工具一般分为两类,一种是jdk自带的工具,一种是第三方的分析工具.jdk自带工具一般在jdk bin目录下面,以 ...
- Java字符串池(String Pool)深度解析
在工作中,String类是我们使用频率非常高的一种对象类型.JVM为了提升性能和减少内存开销,避免字符串的重复创建,其维护了一块特殊的内存空间,这就是我们今天要讨论的核心,即字符串池(String P ...
- Java并发之魂——synchronized深度解析
虽然网上关于Java并发.多线程的文章已是不胜枚举,但是读起来总感觉晦涩且千篇一律,不是你转载我,就是我复制你.因此决定自己总结一下,以便自己常读常新,同时由于并发和多线程这块是面试重点中的重点,也是 ...
最新文章
- 用Windows Live Writer在51CTO写博客
- Makefile中打印变量
- React Native debug debugger
- 论SqlServer中char、varchar、nvarcahr和MySQL中char、varcahr的区别
- vue知识总结第一篇vue组件的定义以及父子组件的传值。
- html两个盒子怎么左右对其,关于html:在同一行上左右对齐两个内联块
- docker php composer 使用_「PHP编程」如何使用Docker制作自己的LNMP/LAMP镜像
- CentOS系统性能工具 sar 示例!
- android拦截黑名单电话和短信
- 摄影基础知识(光圈、快门、感光度等)
- python绘制等边三角形的代码_python绘制等边三角形
- win10 werfault.exe 内存不能read 修复
- Cortex-M3内核之CPU等级模式
- java有关的论述_中国大学MOOC: 以下有关JAVA线程的论述,正确的是()。
- Java——字符缓冲流练习之集合到文件、文件到集合、点名器
- 关于DAO的反身性理论:贡献者不自知的互助性成长
- App渠道统计方法全面解析 总有一种适合你
- C++ | shared_ptr与weak_ptr
- python geany是什么_Geany中怎么配置python?
- 2020秋招笔试题总结(华为、360、京东、中兴、快手、字节跳动、阿里、拼多多、腾讯、VIVO)~持续更新