自拍偷在线精品自拍偷,亚洲欧美中文日韩v在线观看不卡

Java之戳中痛點(diǎn)之synchronized 深度解析

作者：Json_wangqiang
開發(fā) 后端
能夠保證在同一時(shí)刻最多只有一個(gè)線程執(zhí)行該代碼，以保證并發(fā)安全的效果。

 概覽：

  •  簡介：作用、地位、不控制并發(fā)的影響
  •  用法：對(duì)象鎖和類鎖
  •  多線程訪問同步方法的7種情況
  •  性質(zhì)：可重入、不可中斷
  •  原理：加解鎖原理、可重入原理、可見性原理
  •  缺陷：效率低、不夠靈活、無法預(yù)判是否成功獲取到鎖
  •  如何選擇Lock或Synchronized
  •  如何提高性能、JVM如何決定哪個(gè)線程獲取鎖
  •  總結(jié)

后續(xù)會(huì)有代碼演示，測(cè)試環(huán)境 JDK8、IDEA

一、簡介

1、作用

能夠保證在同一時(shí)刻最多只有一個(gè)線程執(zhí)行該代碼，以保證并發(fā)安全的效果。

2、地位

  •  Synchronized是Java關(guān)鍵字，Java原生支持
  •  最基本的互斥同步手段
  •  并發(fā)編程的元老級(jí)別

3、不控制并發(fā)的影響

測(cè)試：兩個(gè)線程同時(shí)a++，猜一下結(jié)果 

  1. package cn.jsonshare.java.base.synchronizedtest;  
  2. /**  
  3.  * 不使用synchronized,兩個(gè)線程同時(shí)a++  
  4.  *  
  5.  * @author JSON  
  6.  */  
  7. public class SynchronizedTest1 implements Runnable{  
  8.     static SynchronizedTest1 st = new SynchronizedTest1();  
  9.     static int a = 0;  
  10.     /**  
  11.      * 不使用synchronized,兩個(gè)線程同時(shí)a++  
  12.      */  
  13.     public static void main(String[] args) throws Exception{  
  14.         Thread t1 = new Thread(st);  
  15.         Thread t2 = new Thread(st);  
  16.         t1.start();  
  17.         t2.start();  
  18.         t1.join();  
  19.         t2.join();  
  20.         System.out.println(a);  
  21.     }  
  22.     @Override  
  23.     public void run(){  
  24.         for(int i=0; i<10000; i++){  
  25.             a++;  
  26.         }  
  27.     }  
  28. } 

預(yù)期是20000，但多次執(zhí)行的結(jié)果都小于20000 

  1. 10108  
  2. 11526  
  3. 10736  
  4. ... 

二、用法：對(duì)象鎖和類鎖

1、對(duì)象鎖

  •  代碼塊形式：手動(dòng)指定鎖對(duì)象
  •  方法鎖形式：synchronized修飾方法，鎖對(duì)象默認(rèn)為this 
  1. package cn.jsonshare.java.base.synchronizedtest;  
  2. /**  
  3.  * 對(duì)象鎖實(shí)例: 代碼塊形式  
  4.  *  
  5.  * @author JSON  
  6.  */  
  7. public class SynchronizedTest2 implements Runnable{  
  8.     static SynchronizedTest2 st = new SynchronizedTest2();  
  9.     public static void main(String[] args) {  
  10.         Thread t1 = new Thread(st);  
  11.         Thread t2 = new Thread(st);  
  12.         t1.start();  
  13.         t2.start();  
  14.         while(t1.isAlive() || t2.isAlive()){  
  15.         }  
  16.         System.out.println("run over");  
  17.     }  
  18.     @Override  
  19.     public void run(){  
  20.         synchronized (this){  
  21.             System.out.println("開始執(zhí)行:" + Thread.currentThread().getName());  
  22.             try {  
  23.                 // 模擬執(zhí)行內(nèi)容  
  24.                 Thread.sleep(3000);  
  25.             }catch (Exception e){  
  26.                 e.printStackTrace();  
  27.             }  
  28.             System.out.println("執(zhí)行結(jié)束:" + Thread.currentThread().getName());  
  29.         }  
  30.     }  
  31. }  
  1. package cn.jsonshare.java.base.synchronizedtest;  
  2. /**  
  3.  * 對(duì)象鎖實(shí)例：synchronized方法  
  4.  * @author JSON 
  5.  */  
  6. public class SynchronizedTest3 implements Runnable{  
  7.     static SynchronizedTest3 st = new SynchronizedTest3();  
  8.     public static void main(String[] args) throws Exception{  
  9.         Thread t1 = new Thread(st);  
  10.         Thread t2 = new Thread(st);  
  11.         t1.start();  
  12.         t2.start();  
  13.         t1.join();  
  14.         t2.join();  
  15.         System.out.println("run over");  
  16.     }  
  17.     @Override  
  18.     public void run(){  
  19.         method();  
  20.     }  
  21.     public synchronized void method(){  
  22.         System.out.println("開始執(zhí)行:" + Thread.currentThread().getName());  
  23.         try {  
  24.             // 模擬執(zhí)行內(nèi)容  
  25.             Thread.sleep(3000);  
  26.         }catch (Exception e){  
  27.             e.printStackTrace();  
  28.         }  
  29.         System.out.println("執(zhí)行結(jié)束:" + Thread.currentThread().getName());  
  30.     }  
  31. } 

結(jié)果： 

  1. 開始執(zhí)行:Thread-0  
  2. 執(zhí)行結(jié)束:Thread-0  
  3. 開始執(zhí)行:Thread-1  
  4. 執(zhí)行結(jié)束:Thread-1  
  5. run over 

2、類鎖

概念：Java類可能有多個(gè)對(duì)象，但只有一個(gè)Class對(duì)象

本質(zhì)：所謂的類鎖，不過是Class對(duì)象的鎖而已

用法和效果：類鎖只能在同一時(shí)刻被一個(gè)對(duì)象擁有

形式1：synchronized加載static方法上

形式2：synchronized(*.class)代碼塊 

  1. package cn.jsonshare.java.base.synchronizedtest;  
  2. /**  
  3.  * 類鎖：synchronized加載static方法上  
  4.  *  
  5.  * @author JSON  
  6.  */  
  7. public class SynchronizedTest4 implements Runnable{  
  8.     static SynchronizedTest4 st1 = new SynchronizedTest4();  
  9.     static SynchronizedTest4 st2 = new SynchronizedTest4();  
  10.     public static void main(String[] args) throws Exception{  
  11.         Thread t1 = new Thread(st1);  
  12.         Thread t2 = new Thread(st2);  
  13.         t1.start();  
  14.         t2.start();  
  15.         t1.join();  
  16.         t2.join();  
  17.         System.out.println("run over");  
  18.     }  
  19.     @Override  
  20.     public void run(){  
  21.         method();  
  22.     }  
  23.     public static synchronized void method(){  
  24.         System.out.println("開始執(zhí)行:" + Thread.currentThread().getName());  
  25.         try {  
  26.             // 模擬執(zhí)行內(nèi)容  
  27.             Thread.sleep(3000);  
  28.         }catch (Exception e){  
  29.             e.printStackTrace();  
  30.         }  
  31.         System.out.println("執(zhí)行結(jié)束:" + Thread.currentThread().getName());  
  32.     }  
  33. }  
  1. package cn.jsonshare.java.base.synchronizedtest;  
  2. /**  
  3.  * 類鎖：synchronized(*.class)代碼塊  
  4.  *  
  5.  * @author JSON  
  6.  */  
  7. public class SynchronizedTest5 implements Runnable{  
  8.     static SynchronizedTest4 st1 = new SynchronizedTest4();  
  9.     static SynchronizedTest4 st2 = new SynchronizedTest4();  
  10.     public static void main(String[] args) throws Exception{  
  11.         Thread t1 = new Thread(st1);  
  12.         Thread t2 = new Thread(st2);  
  13.         t1.start();  
  14.         t2.start();  
  15.         t1.join();  
  16.         t2.join();  
  17.         System.out.println("run over");  
  18.     }  
  19.     @Override  
  20.     public void run(){  
  21.         method();  
  22.     }  
  23.     public void method(){  
  24.         synchronized(SynchronizedTest5.class){  
  25.             System.out.println("開始執(zhí)行:" + Thread.currentThread().getName());  
  26.             try {  
  27.                 // 模擬執(zhí)行內(nèi)容  
  28.                 Thread.sleep(3000);  
  29.             }catch (Exception e){  
  30.                 e.printStackTrace();  
  31.             }  
  32.             System.out.println("執(zhí)行結(jié)束:" + Thread.currentThread().getName());  
  33.         }  
  34.     }  
  35. } 

結(jié)果： 

  1. 開始執(zhí)行:Thread-0  
  2. 執(zhí)行結(jié)束:Thread-0  
  3. 開始執(zhí)行:Thread-1  
  4. 執(zhí)行結(jié)束:Thread-1  
  5. run over 

Java知音公眾號(hào)內(nèi)回復(fù)“面試題聚合”，送你一份面試題寶典

三、多線程訪問同步方法的7種情況

  1.  兩個(gè)線程同時(shí)訪問一個(gè)對(duì)象的相同的synchronized方法
  2.  兩個(gè)線程同時(shí)訪問兩個(gè)對(duì)象的相同的synchronized方法
  3.  兩個(gè)線程同時(shí)訪問兩個(gè)對(duì)象的相同的static的synchronized方法
  4.  兩個(gè)線程同時(shí)訪問同一對(duì)象的synchronized方法與非synchronized方法
  5.  兩個(gè)線程訪問同一對(duì)象的不同的synchronized方法
  6.  兩個(gè)線程同時(shí)訪問同一對(duì)象的static的synchronized方法與非static的synchronized方法
  7.  方法拋出異常后，會(huì)釋放鎖嗎

仔細(xì)看下面示例代碼結(jié)果輸出的結(jié)果，注意輸出時(shí)間間隔，來預(yù)測(cè)結(jié)論

場(chǎng)景1： 

  1. package cn.jsonshare.java.base.synchronizedtest;  
  2. /**  
  3.  * 兩個(gè)線程同時(shí)訪問一個(gè)對(duì)象的相同的synchronized方法  
  4.  *  
  5.  * @author JSON  
  6.  */  
  7. public class SynchronizedScene1 implements Runnable{  
  8.     static SynchronizedScene1 ss = new SynchronizedScene1();  
  9.     public static void main(String[] args) throws Exception{  
  10.         Thread t1 = new Thread(ss);  
  11.         Thread t2 = new Thread(ss);  
  12.         t1.start();  
  13.         t2.start();  
  14.         t1.join();  
  15.         t2.join();  
  16.         System.out.println("run over");  
  17.     }  
  18.     @Override  
  19.     public void run(){  
  20.         method();  
  21.     }  
  22.     public synchronized void method(){  
  23.         System.out.println("開始執(zhí)行:" + Thread.currentThread().getName());  
  24.         try {  
  25.             // 模擬執(zhí)行內(nèi)容  
  26.             Thread.sleep(3000);  
  27.         }catch (Exception e){  
  28.             e.printStackTrace();  
  29.         } 
  30.         System.out.println("執(zhí)行結(jié)束:" + Thread.currentThread().getName());  
  31.     }  
  32. } 

場(chǎng)景2： 

  1. package cn.jsonshare.java.base.synchronizedtest;  
  2. /**  
  3.  * 兩個(gè)線程同時(shí)訪問兩個(gè)對(duì)象的相同的synchronized方法  
  4.  *  
  5.  * @author JSON  
  6.  */  
  7. public class SynchronizedScene2 implements Runnable{  
  8.     static SynchronizedScene2 ss1 = new SynchronizedScene2();  
  9.     static SynchronizedScene2 ss2 = new SynchronizedScene2();  
  10.      public static void main(String[] args) throws Exception{  
  11.         Thread t1 = new Thread(ss1);  
  12.         Thread t2 = new Thread(ss2);  
  13.         t1.start();  
  14.         t2.start();  
  15.         t1.join();  
  16.         t2.join(); 
  17.          System.out.println("run over");  
  18.     }  
  19.     @Override  
  20.     public void run(){  
  21.         method();  
  22.     } 
  23.     public synchronized void method(){  
  24.         System.out.println("開始執(zhí)行:" + Thread.currentThread().getName());  
  25.         try {  
  26.             // 模擬執(zhí)行內(nèi)容  
  27.             Thread.sleep(3000);  
  28.         }catch (Exception e){  
  29.             e.printStackTrace();  
  30.         }  
  31.         System.out.println("執(zhí)行結(jié)束:" + Thread.currentThread().getName());  
  32.     }  
  33. } 

場(chǎng)景3： 

  1. package cn.jsonshare.java.base.synchronizedtest;  
  2. /**  
  3.  * 兩個(gè)線程同時(shí)訪問兩個(gè)對(duì)象的相同的static的synchronized方法  
  4.  *  
  5.  * @author JSON  
  6.  */  
  7. public class SynchronizedScene3 implements Runnable{  
  8.     static SynchronizedScene3 ss1 = new SynchronizedScene3();  
  9.     static SynchronizedScene3 ss2 = new SynchronizedScene3();  
  10.     public static void main(String[] args) throws Exception{  
  11.         Thread t1 = new Thread(ss1);  
  12.         Thread t2 = new Thread(ss2); 
  13.         t1.start();  
  14.         t2.start();  
  15.         t1.join();  
  16.         t2.join();  
  17.         System.out.println("run over");  
  18.     }  
  19.     @Override  
  20.     public void run(){  
  21.         method(); 
  22.      }  
  23.     public synchronized static void method(){  
  24.         System.out.println("開始執(zhí)行:" + Thread.currentThread().getName());  
  25.         try {  
  26.             // 模擬執(zhí)行內(nèi)容  
  27.             Thread.sleep(3000);  
  28.         }catch (Exception e){  
  29.             e.printStackTrace();  
  30.         }  
  31.         System.out.println("執(zhí)行結(jié)束:" + Thread.currentThread().getName());  
  32.     }  
  33. } 

場(chǎng)景4： 

  1. package cn.jsonshare.java.base.synchronizedtest;  
  2. /**  
  3.  * 兩個(gè)線程同時(shí)訪問同一對(duì)象的synchronized方法與非synchronized方法  
  4.  *  
  5.  * @author JSON  
  6.  */  
  7. public class SynchronizedScene4 implements Runnable{  
  8.     static SynchronizedScene4 ss1 = new SynchronizedScene4();  
  9.     public static void main(String[] args) throws Exception{  
  10.         Thread t1 = new Thread(ss1);  
  11.         Thread t2 = new Thread(ss1);  
  12.         t1.start();  
  13.         t2.start();  
  14.         t1.join();  
  15.         t2.join();  
  16.         System.out.println("run over");  
  17.     }  
  18.     @Override  
  19.     public void run(){  
  20.         // 模擬兩個(gè)線程同時(shí)訪問 synchronized方法與非synchronized方法  
  21.         if(Thread.currentThread().getName().equals("Thread-0")){  
  22.             method1();  
  23.         }else{  
  24.             method2();  
  25.         }  
  26.     }  
  27.     public void method1(){  
  28.         System.out.println("method1開始執(zhí)行:" + Thread.currentThread().getName());  
  29.         try {  
  30.             // 模擬執(zhí)行內(nèi)容  
  31.             Thread.sleep(3000);  
  32.         }catch (Exception e){  
  33.             e.printStackTrace();  
  34.         }  
  35.         System.out.println("method1執(zhí)行結(jié)束:" + Thread.currentThread().getName());  
  36.     }  
  37.     public synchronized void method2(){  
  38.         System.out.println("method2開始執(zhí)行:" + Thread.currentThread().getName());  
  39.         try {  
  40.             // 模擬執(zhí)行內(nèi)容  
  41.             Thread.sleep(3000);  
  42.         }catch (Exception e){  
  43.             e.printStackTrace();  
  44.         }  
  45.         System.out.println("method2執(zhí)行結(jié)束:" + Thread.currentThread().getName());  
  46.     }  
  47. } 

場(chǎng)景5： 

  1. package cn.jsonshare.java.base.synchronizedtest;  
  2. /** 
  3.  * 兩個(gè)線程訪問同一對(duì)象的不同的synchronized方法  
  4.  *  
  5.  * @author JSON  
  6.  */  
  7. public class SynchronizedScene5 implements Runnable{  
  8.     static SynchronizedScene5 ss1 = new SynchronizedScene5();  
  9.     public static void main(String[] args) throws Exception{  
  10.         Thread t1 = new Thread(ss1);  
  11.         Thread t2 = new Thread(ss1);  
  12.         t1.start();  
  13.         t2.start();  
  14.         t1.join();  
  15.         t2.join();  
  16.         System.out.println("run over");  
  17.     }  
  18.     @Override  
  19.     public void run(){  
  20.         // 模擬兩個(gè)線程同時(shí)訪問不同的synchronized方法  
  21.         if(Thread.currentThread().getName().equals("Thread-0")){  
  22.             method1(); 
  23.          }else{  
  24.             method2();  
  25.         }  
  26.     }  
  27.     public synchronized void method1(){  
  28.         System.out.println("method1開始執(zhí)行:" + Thread.currentThread().getName());  
  29.         try {  
  30.             // 模擬執(zhí)行內(nèi)容  
  31.             Thread.sleep(3000);  
  32.         }catch (Exception e){  
  33.             e.printStackTrace();  
  34.         }  
  35.         System.out.println("method1執(zhí)行結(jié)束:" + Thread.currentThread().getName());  
  36.     }  
  37.     public synchronized void method2(){  
  38.         System.out.println("method2開始執(zhí)行:" + Thread.currentThread().getName());  
  39.         try {  
  40.             // 模擬執(zhí)行內(nèi)容  
  41.             Thread.sleep(3000);  
  42.         }catch (Exception e){  
  43.             e.printStackTrace();  
  44.         }  
  45.         System.out.println("method2執(zhí)行結(jié)束:" + Thread.currentThread().getName());  
  46.     }  
  47. } 

場(chǎng)景6： 

  1. package cn.jsonshare.java.base.synchronizedtest;  
  2. /**  
  3.  * 兩個(gè)線程同時(shí)訪問同一對(duì)象的static的synchronized方法與非static的synchronized方法  
  4.  *  
  5.  * @author JSON  
  6.  */  
  7. public class SynchronizedScene6 implements Runnable{  
  8.     static SynchronizedScene6 ss1 = new SynchronizedScene6();  
  9.     public static void main(String[] args) throws Exception{  
  10.         Thread t1 = new Thread(ss1);  
  11.         Thread t2 = new Thread(ss1);  
  12.         t1.start();  
  13.         t2.start();  
  14.         t1.join(); 
  15.         t2.join();  
  16.         System.out.println("run over");  
  17.     }  
  18.     @Override  
  19.     public void run(){  
  20.         // 模擬兩個(gè)線程同時(shí)訪問static的synchronized方法與非static的synchronized方法  
  21.         if(Thread.currentThread().getName().equals("Thread-0")){  
  22.             method1();  
  23.         }else{  
  24.             method2();  
  25.         }  
  26.     }  
  27.     public static synchronized void method1(){  
  28.         System.out.println("method1開始執(zhí)行:" + Thread.currentThread().getName());  
  29.         try {  
  30.             // 模擬執(zhí)行內(nèi)容  
  31.             Thread.sleep(3000);  
  32.         }catch (Exception e){  
  33.             e.printStackTrace();  
  34.         }  
  35.         System.out.println("method1執(zhí)行結(jié)束:" + Thread.currentThread().getName());  
  36.     }  
  37.     public synchronized void method2(){  
  38.         System.out.println("method2開始執(zhí)行:" + Thread.currentThread().getName());  
  39.         try {  
  40.             // 模擬執(zhí)行內(nèi)容  
  41.             Thread.sleep(3000);  
  42.         }catch (Exception e){  
  43.             e.printStackTrace(); 
  44.          }  
  45.         System.out.println("method2執(zhí)行結(jié)束:" + Thread.currentThread().getName());  
  46.     }  
  47. } 

場(chǎng)景7： 

  1. package cn.jsonshare.java.base.synchronizedtest;  
  2. /**  
  3.  * 方法拋出異常后，會(huì)釋放鎖嗎  
  4.  *  
  5.  * @author JSON  
  6.  */  
  7. public class SynchronizedScene7 implements Runnable{  
  8.     static SynchronizedScene7 ss1 = new SynchronizedScene7();  
  9.     public static void main(String[] args) throws Exception{  
  10.         Thread t1 = new Thread(ss1);  
  11.         Thread t2 = new Thread(ss1);  
  12.         t1.start();  
  13.         t2.start();  
  14.         t1.join();  
  15.         t2.join();  
  16.         System.out.println("run over");  
  17.     }  
  18.     @Override  
  19.     public void run(){  
  20.         method1();  
  21.     }  
  22.     public synchronized void method1(){  
  23.         System.out.println("method1開始執(zhí)行:" + Thread.currentThread().getName());  
  24.         try { 
  25.              // 模擬執(zhí)行內(nèi)容  
  26.             Thread.sleep(3000);  
  27.         }catch (Exception e){  
  28.             e.printStackTrace();  
  29.         }  
  30.         // 模擬異常  
  31.         throw new RuntimeException();  
  32.         //System.out.println("method1執(zhí)行結(jié)束:" + Thread.currentThread().getName());  
  33.     }  
  34. } 

Java知音公眾號(hào)內(nèi)回復(fù)“面試題聚合”，送你一份面試題寶典

總結(jié)：

1、兩個(gè)線程同時(shí)訪問一個(gè)對(duì)象的相同的synchronized方法

同一實(shí)例擁有同一把鎖，其他線程必然等待，順序執(zhí)行

2、兩個(gè)線程同時(shí)訪問兩個(gè)對(duì)象的相同的synchronized方法

不同的實(shí)例擁有的鎖是不同的，所以不影響，并行執(zhí)行

3、兩個(gè)線程同時(shí)訪問兩個(gè)對(duì)象的相同的static的synchronized方法

靜態(tài)同步方法，是類鎖，所有實(shí)例是同一把鎖，其他線程必然等待，順序執(zhí)行

4、兩個(gè)線程同時(shí)訪問同一對(duì)象的synchronized方法與非synchronized方法

非synchronized方法不受影響，并行執(zhí)行

5、兩個(gè)線程訪問同一對(duì)象的不同的synchronized方法

同一實(shí)例擁有同一把鎖，所以順序執(zhí)行（說明：鎖的是this對(duì)象==同一把鎖）

6、兩個(gè)線程同時(shí)訪問同一對(duì)象的static的synchronized方法與非static的synchronized方法

static同步方法是類鎖，非static是對(duì)象鎖，原理上是不同的鎖，所以不受影響，并行執(zhí)行

7、方法拋出異常后，會(huì)釋放鎖嗎

會(huì)自動(dòng)釋放鎖，這里區(qū)別Lock，Lock需要顯示的釋放鎖

3個(gè)核心思想：

  •  一把鎖只能同時(shí)被一個(gè)線程獲取，沒有拿到鎖的線程必須等待（對(duì)應(yīng)1、5的情景）
  •  每個(gè)實(shí)例都對(duì)應(yīng)有自己的一把鎖，不同的實(shí)例之間互不影響；例外：鎖對(duì)象是*.class以及synchronized被static修飾的時(shí)候，所有對(duì)象共用同一把鎖（對(duì)應(yīng)2、3、4、6情景）
  •  無論是方法正常執(zhí)行完畢還是方法拋出異常，都會(huì)釋放鎖（對(duì)應(yīng)7情景）

補(bǔ)充：

問題：目前進(jìn)入到被synchronized修飾的方法，這個(gè)方法里邊調(diào)用了非synchronized方法，是線程安全的嗎？ 

  1. package cn.jsonshare.java.base.synchronizedtest;  
  2. /**  
  3.  * 目前進(jìn)入到被synchronized修飾的方法，這個(gè)方法里邊調(diào)用了非synchronized方法，是線程安全的嗎？  
  4.  *  
  5.  * @author JSON  
  6.  */  
  7. public class SynchronizedScene8 { 
  8.     public static void main(String[] args) {  
  9.         new Thread(() -> {  
  10.             method1();  
  11.         }).start();  
  12.         new Thread(() -> {  
  13.             method1();  
  14.         }).start(); 
  15.      }  
  16.     public static synchronized void method1() {  
  17.         method2();  
  18.     }  
  19.     private static void method2() {  
  20.         System.out.println(Thread.currentThread().getName() + "進(jìn)入非Synchronized方法");  
  21.         try {  
  22.             Thread.sleep(3000);  
  23.         } catch (InterruptedException e) {  
  24.             e.printStackTrace();  
  25.         }  
  26.         System.out.println(Thread.currentThread().getName() + "結(jié)束非Synchronized方法");  
  27.     }  
  28. } 

結(jié)論：這樣是線程安全的

四、性質(zhì)

1、可重入

指的是同一線程的外層函數(shù)獲取鎖之后，內(nèi)層函數(shù)可以直接再次獲取該鎖

Java典型的可重入鎖：synchronized、ReentrantLock

好處：避免死鎖，提升封裝性

粒度：線程而非調(diào)用

  •  情況1：證明同一方法是可重入的
  •  情況2：證明可重入不要求是同一方法
  •  情況3：證明可重入不要求是同一類中的

2、不可中斷

一旦這個(gè)鎖被別的線程獲取了，如果我現(xiàn)在想獲得，我只能選擇等待或者阻塞，直到別的線程釋放這個(gè)鎖，如果別的線程永遠(yuǎn)不釋放鎖，那么我只能永遠(yuǎn)的等待下去。

相比之下，Lock類可以擁有中斷的能力，第一點(diǎn)：如果我覺得我等待的時(shí)間太長了，有權(quán)中斷現(xiàn)在已經(jīng)獲取到鎖的線程執(zhí)行；第二點(diǎn)：如果我覺得我等待的時(shí)間太長了不想再等了，也可以退出。

五、原理

1、加解鎖原理（現(xiàn)象、時(shí)機(jī)、深入JVM看字節(jié)碼）

現(xiàn)象：每一個(gè)類的實(shí)例對(duì)應(yīng)一把鎖，每一個(gè)synchronized方法都必須首先獲得調(diào)用該方法的類的實(shí)例的鎖，方能執(zhí)行，否則就會(huì)阻塞，方法執(zhí)行完成或者拋出異常，鎖被釋放，被阻塞線程才能獲取到該鎖，執(zhí)行。

獲取和釋放鎖的時(shí)機(jī)：內(nèi)置鎖或監(jiān)視器鎖 

  1. package cn.jsonshare.java.base.synchronizedtest; 
  2. import java.util.concurrent.locks.Lock;  
  3. import java.util.concurrent.locks.ReentrantLock;  
  4. /**  
  5.  * method1 等價(jià)于 method2  
  6.  *  
  7.  * @author JSON  
  8.  * @date 2019-08-29  
  9.  */  
  10. public class SynchronizedToLock1 {  
  11.     Lock lock = new ReentrantLock();  
  12.     public synchronized void method1(){  
  13.         System.out.println("執(zhí)行method1");  
  14.     }  
  15.     public void method2(){  
  16.         lock.lock();  
  17.         try {  
  18.             System.out.println("執(zhí)行method2");  
  19.         }catch (Exception e){  
  20.             e.printStackTrace();  
  21.         }finally {  
  22.             lock.unlock();  
  23.         }  
  24.     } 
  25.     public static void main(String[] args) {  
  26.         SynchronizedToLock1 sl = new SynchronizedToLock1();  
  27.         // method1 等價(jià)于 method2  
  28.         sl.method1();  
  29.         sl.method2();  
  30.     }  
  31. } 

深入JVM看字節(jié)碼： 

  1. ...  
  2. monitorenter指令  
  3. ...  
  4. monitorexit指令  
  5. ... 

2、可重入原理（加鎖次數(shù)計(jì)數(shù)器）

JVM負(fù)責(zé)跟蹤對(duì)象被加鎖的次數(shù)

線程第一次給對(duì)象加鎖的時(shí)候，計(jì)數(shù)變?yōu)?，每當(dāng)這個(gè)相同的線程在此對(duì)象上再次獲得鎖時(shí)，計(jì)數(shù)會(huì)遞增

每當(dāng)任務(wù)離開時(shí)，計(jì)數(shù)遞減，當(dāng)計(jì)數(shù)為0的時(shí)候，鎖被完全釋放

3、可見性原理（內(nèi)存模型）

Java內(nèi)存模型

線程A向線程B發(fā)送數(shù)據(jù)的過程（JMM控制）

synchronized關(guān)鍵字實(shí)現(xiàn)可見性：

被synchronized修飾，那么執(zhí)行完成后，對(duì)對(duì)象所做的任何修改都要在釋放鎖之前，都要從線程內(nèi)存寫入到主內(nèi)存，所以主內(nèi)存中的數(shù)據(jù)是最新的。

六、缺陷

1、效率低

1)、鎖的釋放情況少（線程執(zhí)行完成或者異常情況釋放）

2)、試圖獲得鎖時(shí)不能設(shè)定超時(shí)（只能等待）

3)、不能中斷一個(gè)正在試圖獲得鎖的線程（不能中斷）

2、不夠靈活

加鎖和釋放的時(shí)機(jī)比較單一，每個(gè)鎖僅有單一的條件（某個(gè)對(duì)象），可能是不夠的

比如：讀寫鎖更靈活

3、無法預(yù)判是否成功獲取到鎖

七、常見問題

1、synchronized關(guān)鍵字注意點(diǎn)：

  •  鎖對(duì)象不能為空
  •  作用域不宜過大
  •  避免死鎖

2、如何選擇Lock和synchronized關(guān)鍵字？

總結(jié)建議（優(yōu)先避免出錯(cuò)的原則）：

  •  如果可以的話，盡量優(yōu)先使用java.util.concurrent各種類（不需要考慮同步工作，不容易出錯(cuò)）
  •  優(yōu)先使用synchronized，這樣可以減少編寫代碼的量，從而可以減少出錯(cuò)率
  •  若用到Lock或Condition獨(dú)有的特性，才使用Lock或Condition

八、總結(jié)

一句話總結(jié)synchronized：

JVM會(huì)自動(dòng)通過使用monitor來加鎖和解鎖，保證了同一時(shí)刻只有一個(gè)線程可以執(zhí)行指定的代碼，從而保證線程安全，同時(shí)具有可重入和不可中斷的特性。  

 

責(zé)任編輯：龐桂玉 來源： Java知音
Javasynchronized代碼
相關(guān)推薦

2019-04-16 10:53:47

ERP企業(yè)信息化

2019-04-16 12:55:42

ERPCEO企業(yè)

2013-06-04 09:46:17

聯(lián)調(diào)開發(fā)團(tuán)隊(duì)

2022-12-07 08:02:43

Spring流程IOC

2022-02-18 09:40:44

云原生邊緣計(jì)算云計(jì)算

2021-09-16 06:44:05

組合模式設(shè)計(jì)

2024-06-13 09:12:38

2013-03-26 11:20:05

創(chuàng)業(yè)創(chuàng)業(yè)者創(chuàng)業(yè)失敗

2014-09-22 15:33:54

2018-08-06 06:57:49

物聯(lián)網(wǎng)IOT物聯(lián)網(wǎng)設(shè)備

2011-06-07 17:16:47

iPhone 數(shù)據(jù)

2009-07-22 15:47:05

軟件質(zhì)量管理

2024-11-20 15:55:57

線程Java開發(fā)

2019-12-20 15:19:41

Synchroinze線程安全

2023-07-02 06:47:42

LOFTER系統(tǒng)架構(gòu)

2021-08-03 07:40:46

Synchronize鎖膨脹性能

2017-11-21 14:27:46

容器DockerLinux

2018-08-06 15:41:49

2018-11-13 14:41:35

溯源區(qū)塊鏈商場(chǎng)

2017-03-08 10:06:11

Java技術(shù)點(diǎn)注解
點(diǎn)贊
收藏

51CTO技術(shù)棧公眾號(hào)