Java之戳中痛點 - （8）synchronized深度解析
概覽：
- 簡介：做用、地位、不控制併發的影響
- 用法：對象鎖和類鎖
- 多線程訪問同步方法的7種狀況
- 性質：可重入、不可中斷
- 原理：加解鎖原理、可重入原理、可見性原理
- 缺陷：效率低、不夠靈活、沒法預判是否成功獲取到鎖
- 如何選擇Lock或Synchronized
- 如何提升性能、JVM如何決定哪一個線程獲取鎖
- 總結
後續會有代碼演示，測試環境 JDK八、IDEA
1、簡介
一、做用
可以保證在==同一時刻==最多隻有一個線程執行該代碼，以保證併發安全的效果。java
二、地位
- Synchronized是Java關鍵字，Java原生支持
- 最基本的互斥同步手段
- 併發編程的元老級別
三、不控制併發的影響
測試：兩個線程同時a++，猜一下結果編程
package cn.jsonshare.java.base.synchronizedtest;
/**
* 不使用synchronized,兩個線程同時a++
*
* @author JSON
* @date 2019-08-29
*/
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);
}
@Override
public void run(){
for(int i=0; i<10000; i++){
a++;
}
}
}
預期是20000，但屢次執行的結果都小於20000json
10108 11526 10736 ...
2、用法：對象鎖和類鎖
一、對象鎖
- 代碼塊形式：手動指定鎖對象
- 方法鎖形式：synchronized修飾方法，鎖對象默認爲this
package cn.jsonshare.java.base.synchronizedtest;
/**
* 對象鎖實例: 代碼塊形式
*
* @author JSON
* @date 2019-08-29
*/
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");
}
@Override
public 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
* @date 2019-08-29
*/
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");
}
@Override
public 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
二、類鎖
==概念：Java類可能有多個對象，但只有一個Class對象==多線程
==本質：所謂的類鎖，不過是Class對象的鎖而已==併發
==用法和效果：類鎖只能在同一時刻被一個對象擁有==jvm
形式1：synchronized加載static方法上ide
形式2：synchronized(*.class)代碼塊函數
package cn.jsonshare.java.base.synchronizedtest;
/**
* 類鎖：synchronized加載static方法上
*
* @author JSON
* @date 2019-08-29
*/
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");
}
@Override
public 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
* @date 2019-08-29
*/
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");
}
@Override
public 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
3、多線程訪問同步方法的7種狀況
- 兩個線程同時訪問一個對象的相同的synchronized方法
- 兩個線程同時訪問兩個對象的相同的synchronized方法
- 兩個線程同時訪問兩個對象的相同的static的synchronized方法
- 兩個線程同時訪問同一對象的synchronized方法與非synchronized方法
- 兩個線程訪問同一對象的不一樣的synchronized方法
- 兩個線程同時訪問同一對象的static的synchronized方法與非static的synchronized方法
- 方法拋出異常後，會釋放鎖嗎
仔細看下面示例代碼結果輸出的結果，注意輸出時間間隔，來預測結論
場景1：
package cn.jsonshare.java.base.synchronizedtest;
/**
* 兩個線程同時訪問一個對象的相同的synchronized方法
*
* @author JSON
* @date 2019-08-29
*/
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");
}
@Override
public 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
* @date 2019-08-29
*/
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");
}
@Override
public 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
* @date 2019-08-29
*/
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");
}
@Override
public 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
* @date 2019-08-29
*/
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");
}
@Override
public 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
* @date 2019-08-29
*/
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");
}
@Override
public 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
* @date 2019-08-29
*/
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");
}
@Override
public 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
* @date 2019-08-29
*/
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");
}
@Override
public 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());
}
}
總結：
一、兩個線程同時訪問一個對象的相同的synchronized方法
同一實例擁有同一把鎖，其餘線程必然等待，順序執行
二、兩個線程同時訪問兩個對象的相同的synchronized方法
不一樣的實例擁有的鎖是不一樣的，因此不影響，並行執行
三、兩個線程同時訪問兩個對象的相同的static的synchronized方法
靜態同步方法，是類鎖，全部實例是同一把鎖，其餘線程必然等待，順序執行
四、兩個線程同時訪問同一對象的synchronized方法與非synchronized方法
非synchronized方法不受影響，並行執行
五、兩個線程訪問同一對象的不一樣的synchronized方法
同一實例擁有同一把鎖，因此順序執行（說明：鎖的是this對象==同一把鎖）
六、兩個線程同時訪問同一對象的static的synchronized方法與非static的synchronized方法
static同步方法是類鎖，非static是對象鎖，原理上是不一樣的鎖，因此不受影響，並行執行
七、方法拋出異常後，會釋放鎖嗎
會自動釋放鎖，這裏區別Lock，Lock須要顯示的釋放鎖
3個核心思想：
一、一把鎖只能同時被一個線程獲取，沒有拿到鎖的線程必須等待（對應一、5的情景）
二、每一個實例都對應有本身的一把鎖，不一樣的實例之間互不影響；
例外：鎖對象是*.class以及synchronized被static修飾的時候，全部對象共用同一把鎖（對應二、三、四、6情景）
三、不管是方法正常執行完畢仍是方法拋出異常，都會釋放鎖（對應7情景）
補充：
問題：目前進入到被synchronized修飾的方法，這個方法裏邊調用了非synchronized方法，是線程安全的嗎？
package cn.jsonshare.java.base.synchronizedtest;
/**
* 目前進入到被synchronized修飾的方法，這個方法裏邊調用了非synchronized方法，是線程安全的嗎？
*
* @author JSON
* @date 2019-08-29
*/
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方法");
}
}
結論：這樣是線程安全的
4、性質
一、可重入
指的是同一線程的外層函數獲取鎖以後，內層函數能夠直接再次獲取該鎖
Java典型的可重入鎖：synchronized、ReentrantLock
好處：避免死鎖，提高封裝性
粒度：線程而非調用
狀況1：證實同一方法是可重入的 狀況2：證實可重入不要求是同一方法 狀況3：證實可重入不要求是同一類中的
二、不可中斷
一旦這個鎖被別的線程獲取了，若是我如今想得到，我只能選擇等待或者阻塞，直到別的線程釋放這個鎖，若是別的線程永遠不釋放鎖，那麼我只能永遠的等待下去。
相比之下，Lock類能夠擁有中斷的能力，第一點：若是我以爲我等待的時間太長了，有權中斷如今已經獲取到鎖的線程執行；第二點：若是我以爲我等待的時間太長了不想再等了，也能夠退出。
5、原理
一、加解鎖原理（現象、時機、深刻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 等價於 method2
sl.method1();
sl.method2();
}
}
深刻JVM看字節碼：
... monitorenter指令 ... monitorexit指令 ...
二、可重入原理（加鎖次數計數器）
JVM負責跟蹤對象被加鎖的次數
線程第一次給對象加鎖的時候，計數變爲1，每當這個相同的線程在此對象上再次得到鎖時，計數會遞增
每當任務離開時，計數遞減，當計數爲0的時候，鎖被徹底釋放
三、可見性原理（內存模型）
Java內存模型
線程A向線程B發送數據的過程（JMM控制）
==synchronized關鍵字實現可見性：==
被synchronized修飾，那麼執行完成後，對對象所作的任何修改都要在釋放鎖以前，都要從線程內存寫入到主內存，因此主內存中的數據是最新的。
6、缺陷
一、效率低
1)、鎖的釋放狀況少（線程執行完成或者異常狀況釋放）
2)、試圖得到鎖時不能設定超時（只能等待）
3)、不能中斷一個正在試圖得到鎖的線程（不能中斷）
二、不夠靈活
加鎖和釋放的時機比較單一，每一個鎖僅有單一的條件（某個對象），多是不夠的
好比：讀寫鎖更靈活
三、沒法預判是否成功獲取到鎖
7、常見問題
一、synchronized關鍵字注意點：
- 鎖對象不能爲空
- 做用域不宜過大
- 避免死鎖
二、如何選擇Lock和synchronized關鍵字？
總結建議（優先避免出錯的原則）：
- 若是能夠的話，儘可能優先使用java.util.concurrent各類類（不須要考慮同步工做，不容易出錯）
- 優先使用synchronized，這樣能夠減小編寫代碼的量，從而能夠減小出錯率
- 若用到Lock或Condition獨有的特性，才使用Lock或Condition
8、總結
一句話總結synchronized：
JVM會自動經過使用monitor來加鎖和解鎖，保證了同一時刻只有一個線程能夠執行指定的代碼，從而保證線程安全，同時具備可重入和不可中斷的特性。
相關文章
- 1. Java之戳中痛點 - （8）synchronized深度解析
- 2. Java 8之FunctionalInterface深度解析（一）
- 3. Java之戳中痛點 - （7）善用Java整型緩存池
- 4. 基於synchronized鎖的深度解析
- 5. Java高併發之魂：synchronized深度解析2
- 6. Java併發之synchronized關鍵字深度解析（二）
- 7. Java併發之synchronized關鍵字深度解析（一）
- 8. Java 8 Optional類深度解析
- 9. Java synchronized實現原理深度剖析
- 10. java中++深度解析
- 更多相關文章...
- • XML DOM 解析器 - XML DOM 教程
- • Java 中操作 R - R 語言教程
- • Java 8 Stream 教程
- • 算法總結-深度優先算法
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. Duang!超快Wi-Fi來襲
- 2. 機器學習-補充03 神經網絡之**函數(Activation Function)
- 3. git上開源maven項目部署 多module maven項目（多module maven+redis+tomcat+mysql）後臺部署流程學習記錄
- 4. ecliple-tomcat部署maven項目方式之一
- 5. eclipse新導入的項目經常可以看到「XX cannot be resolved to a type」的報錯信息
- 6. Spark RDD的依賴於DAG的工作原理
- 7. VMware安裝CentOS-8教程詳解
- 8. YDOOK：Java 項目 Spring 項目導入基本四大 jar 包 導入依賴，怎樣在 IDEA 的項目結構中導入 jar 包 導入依賴
- 9. 簡單方法使得putty（windows10上）可以免密登錄樹莓派
- 10. idea怎麼用本地maven
歡迎關注本站公眾號,獲取更多信息
相關文章