成人免费xxxxx在线视频软件_久久精品久久久_亚洲国产精品久久久_天天色天天色_亚洲人成一区_欧美一级欧美三级在线观看

Java之戳中痛點之synchronized 深度解析

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

 概覽：

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

后續會有代碼演示，測試環境 JDK8、IDEA

一、簡介

1、作用

能夠保證在同一時刻最多只有一個線程執行該代碼，以保證并發安全的效果。

2、地位

  •  Synchronized是Java關鍵字，Java原生支持
  •  最基本的互斥同步手段
  •  并發編程的元老級別

3、不控制并發的影響

測試：兩個線程同時a++，猜一下結果 

  1. package cn.jsonshare.java.base.synchronizedtest;  
  2. /**  
  3.  * 不使用synchronized,兩個線程同時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,兩個線程同時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. } 

預期是20000，但多次執行的結果都小于20000 

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

二、用法：對象鎖和類鎖

1、對象鎖

  •  代碼塊形式：手動指定鎖對象
  •  方法鎖形式：synchronized修飾方法，鎖對象默認為this 
  1. package cn.jsonshare.java.base.synchronizedtest;  
  2. /**  
  3.  * 對象鎖實例: 代碼塊形式  
  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("開始執行:" + Thread.currentThread().getName());  
  22.             try {  
  23.                 // 模擬執行內容  
  24.                 Thread.sleep(3000);  
  25.             }catch (Exception e){  
  26.                 e.printStackTrace();  
  27.             }  
  28.             System.out.println("執行結束:" + Thread.currentThread().getName());  
  29.         }  
  30.     }  
  31. }  
  1. package cn.jsonshare.java.base.synchronizedtest;  
  2. /**  
  3.  * 對象鎖實例：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("開始執行:" + Thread.currentThread().getName());  
  23.         try {  
  24.             // 模擬執行內容  
  25.             Thread.sleep(3000);  
  26.         }catch (Exception e){  
  27.             e.printStackTrace();  
  28.         }  
  29.         System.out.println("執行結束:" + Thread.currentThread().getName());  
  30.     }  
  31. } 

結果： 

  1. 開始執行:Thread-0  
  2. 執行結束:Thread-0  
  3. 開始執行:Thread-1  
  4. 執行結束:Thread-1  
  5. run over 

2、類鎖

概念：Java類可能有多個對象，但只有一個Class對象

本質：所謂的類鎖，不過是Class對象的鎖而已

用法和效果：類鎖只能在同一時刻被一個對象擁有

形式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("開始執行:" + Thread.currentThread().getName());  
  25.         try {  
  26.             // 模擬執行內容  
  27.             Thread.sleep(3000);  
  28.         }catch (Exception e){  
  29.             e.printStackTrace();  
  30.         }  
  31.         System.out.println("執行結束:" + 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("開始執行:" + Thread.currentThread().getName());  
  26.             try {  
  27.                 // 模擬執行內容  
  28.                 Thread.sleep(3000);  
  29.             }catch (Exception e){  
  30.                 e.printStackTrace();  
  31.             }  
  32.             System.out.println("執行結束:" + Thread.currentThread().getName());  
  33.         }  
  34.     }  
  35. } 

結果： 

  1. 開始執行:Thread-0  
  2. 執行結束:Thread-0  
  3. 開始執行:Thread-1  
  4. 執行結束:Thread-1  
  5. run over 

Java知音公眾號內回復“面試題聚合”，送你一份面試題寶典

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

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

仔細看下面示例代碼結果輸出的結果，注意輸出時間間隔，來預測結論

場景1： 

  1. package cn.jsonshare.java.base.synchronizedtest;  
  2. /**  
  3.  * 兩個線程同時訪問一個對象的相同的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("開始執行:" + Thread.currentThread().getName());  
  24.         try {  
  25.             // 模擬執行內容  
  26.             Thread.sleep(3000);  
  27.         }catch (Exception e){  
  28.             e.printStackTrace();  
  29.         } 
  30.         System.out.println("執行結束:" + Thread.currentThread().getName());  
  31.     }  
  32. } 

場景2： 

  1. package cn.jsonshare.java.base.synchronizedtest;  
  2. /**  
  3.  * 兩個線程同時訪問兩個對象的相同的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("開始執行:" + Thread.currentThread().getName());  
  25.         try {  
  26.             // 模擬執行內容  
  27.             Thread.sleep(3000);  
  28.         }catch (Exception e){  
  29.             e.printStackTrace();  
  30.         }  
  31.         System.out.println("執行結束:" + Thread.currentThread().getName());  
  32.     }  
  33. } 

場景3： 

  1. package cn.jsonshare.java.base.synchronizedtest;  
  2. /**  
  3.  * 兩個線程同時訪問兩個對象的相同的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("開始執行:" + Thread.currentThread().getName());  
  25.         try {  
  26.             // 模擬執行內容  
  27.             Thread.sleep(3000);  
  28.         }catch (Exception e){  
  29.             e.printStackTrace();  
  30.         }  
  31.         System.out.println("執行結束:" + Thread.currentThread().getName());  
  32.     }  
  33. } 

場景4： 

  1. package cn.jsonshare.java.base.synchronizedtest;  
  2. /**  
  3.  * 兩個線程同時訪問同一對象的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.         // 模擬兩個線程同時訪問 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開始執行:" + Thread.currentThread().getName());  
  29.         try {  
  30.             // 模擬執行內容  
  31.             Thread.sleep(3000);  
  32.         }catch (Exception e){  
  33.             e.printStackTrace();  
  34.         }  
  35.         System.out.println("method1執行結束:" + Thread.currentThread().getName());  
  36.     }  
  37.     public synchronized void method2(){  
  38.         System.out.println("method2開始執行:" + Thread.currentThread().getName());  
  39.         try {  
  40.             // 模擬執行內容  
  41.             Thread.sleep(3000);  
  42.         }catch (Exception e){  
  43.             e.printStackTrace();  
  44.         }  
  45.         System.out.println("method2執行結束:" + Thread.currentThread().getName());  
  46.     }  
  47. } 

場景5： 

  1. package cn.jsonshare.java.base.synchronizedtest;  
  2. /** 
  3.  * 兩個線程訪問同一對象的不同的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.         // 模擬兩個線程同時訪問不同的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開始執行:" + Thread.currentThread().getName());  
  29.         try {  
  30.             // 模擬執行內容  
  31.             Thread.sleep(3000);  
  32.         }catch (Exception e){  
  33.             e.printStackTrace();  
  34.         }  
  35.         System.out.println("method1執行結束:" + Thread.currentThread().getName());  
  36.     }  
  37.     public synchronized void method2(){  
  38.         System.out.println("method2開始執行:" + Thread.currentThread().getName());  
  39.         try {  
  40.             // 模擬執行內容  
  41.             Thread.sleep(3000);  
  42.         }catch (Exception e){  
  43.             e.printStackTrace();  
  44.         }  
  45.         System.out.println("method2執行結束:" + Thread.currentThread().getName());  
  46.     }  
  47. } 

場景6： 

  1. package cn.jsonshare.java.base.synchronizedtest;  
  2. /**  
  3.  * 兩個線程同時訪問同一對象的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.         // 模擬兩個線程同時訪問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開始執行:" + Thread.currentThread().getName());  
  29.         try {  
  30.             // 模擬執行內容  
  31.             Thread.sleep(3000);  
  32.         }catch (Exception e){  
  33.             e.printStackTrace();  
  34.         }  
  35.         System.out.println("method1執行結束:" + Thread.currentThread().getName());  
  36.     }  
  37.     public synchronized void method2(){  
  38.         System.out.println("method2開始執行:" + Thread.currentThread().getName());  
  39.         try {  
  40.             // 模擬執行內容  
  41.             Thread.sleep(3000);  
  42.         }catch (Exception e){  
  43.             e.printStackTrace(); 
  44.          }  
  45.         System.out.println("method2執行結束:" + Thread.currentThread().getName());  
  46.     }  
  47. } 

場景7： 

  1. package cn.jsonshare.java.base.synchronizedtest;  
  2. /**  
  3.  * 方法拋出異常后，會釋放鎖嗎  
  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開始執行:" + Thread.currentThread().getName());  
  24.         try { 
  25.              // 模擬執行內容  
  26.             Thread.sleep(3000);  
  27.         }catch (Exception e){  
  28.             e.printStackTrace();  
  29.         }  
  30.         // 模擬異常  
  31.         throw new RuntimeException();  
  32.         //System.out.println("method1執行結束:" + Thread.currentThread().getName());  
  33.     }  
  34. } 

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方法，是線程安全的嗎？ 

  1. package cn.jsonshare.java.base.synchronizedtest;  
  2. /**  
  3.  * 目前進入到被synchronized修飾的方法，這個方法里邊調用了非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() + "進入非Synchronized方法");  
  21.         try {  
  22.             Thread.sleep(3000);  
  23.         } catch (InterruptedException e) {  
  24.             e.printStackTrace();  
  25.         }  
  26.         System.out.println(Thread.currentThread().getName() + "結束非Synchronized方法");  
  27.     }  
  28. } 

結論：這樣是線程安全的

四、性質

1、可重入

指的是同一線程的外層函數獲取鎖之后，內層函數可以直接再次獲取該鎖

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

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

粒度：線程而非調用

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

2、不可中斷

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

相比之下，Lock類可以擁有中斷的能力，第一點：如果我覺得我等待的時間太長了，有權中斷現在已經獲取到鎖的線程執行；第二點：如果我覺得我等待的時間太長了不想再等了，也可以退出。

五、原理

1、加解鎖原理（現象、時機、深入JVM看字節碼）

現象：每一個類的實例對應一把鎖，每一個synchronized方法都必須首先獲得調用該方法的類的實例的鎖，方能執行，否則就會阻塞，方法執行完成或者拋出異常，鎖被釋放，被阻塞線程才能獲取到該鎖，執行。

獲取和釋放鎖的時機：內置鎖或監視器鎖 

  1. package cn.jsonshare.java.base.synchronizedtest; 
  2. import java.util.concurrent.locks.Lock;  
  3. import java.util.concurrent.locks.ReentrantLock;  
  4. /**  
  5.  * method1 等價于 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("執行method1");  
  14.     }  
  15.     public void method2(){  
  16.         lock.lock();  
  17.         try {  
  18.             System.out.println("執行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 等價于 method2  
  28.         sl.method1();  
  29.         sl.method2();  
  30.     }  
  31. } 

深入JVM看字節碼： 

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

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來加鎖和解鎖，保證了同一時刻只有一個線程可以執行指定的代碼，從而保證線程安全，同時具有可重入和不可中斷的特性。  

 

責任編輯：龐桂玉 來源： Java知音
Javasynchronized代碼
相關推薦

2019-04-16 12:55:42

ERPCEO企業

2019-04-16 10:53:47

ERP企業信息化

2013-06-04 09:46:17

聯調開發團隊

2022-12-07 08:02:43

Spring流程IOC

2022-02-18 09:40:44

云原生邊緣計算云計算

2013-03-26 11:20:05

創業創業者創業失敗

2021-09-16 06:44:05

組合模式設計

2024-06-13 09:12:38

2018-08-06 06:57:49

物聯網IOT物聯網設備

2014-09-22 15:33:54

2011-06-07 17:16:47

iPhone 數據

2009-07-22 15:47:05

軟件質量管理

2019-12-20 15:19:41

Synchroinze線程安全

2023-07-02 06:47:42

LOFTER系統架構

2018-08-06 15:41:49

2018-11-13 14:41:35

溯源區塊鏈商場

2017-11-21 14:27:46

容器DockerLinux

2024-11-20 15:55:57

線程Java開發

2021-08-03 07:40:46

Synchronize鎖膨脹性能

2013-04-07 09:49:14

應用集成云集成集成服務
點贊
收藏

51CTO技術棧公眾號

主站蜘蛛池模板： 天天久久 | 一本一道久久a久久精品蜜桃 | 一二三四在线视频观看社区 | 久久成人精品视频 | 日本二区 | 欧美一级二级三级视频 | 午夜激情国产 | 中文字幕日韩在线 | 亚洲乱码一区二区 | 免费一区二区 | 一区免费 | xxx国产精品视频 | 精品欧美乱码久久久久久 | 一区二区三 | av在线免费观看网址 | 午夜精品一区二区三区在线视频 | 毛片免费看 | 国产精品精品视频一区二区三区 | 黄色大全免费看 | 色一级片| av中文在线| 午夜成人免费视频 | 亚洲精品一 | 91精品91久久久 | 欧美精品一区二区在线观看 | 亚洲国产一区二区三区在线观看 | 国产在线对白 | 亚洲精品www久久久久久广东 | 一区二区三区福利视频 | 日韩精品a在线观看图片 | h视频在线播放 | 91视频91| 国产成人综合一区二区三区 | 国产精品观看 | 亚洲午夜精品视频 | 国产欧美三区 | 国产网站在线播放 | 91中文字幕在线观看 | 中文字幕精品一区二区三区精品 | 丝袜美腿一区 | 亚洲男人天堂2024 |