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

詳解Synchronized鎖的各種用法及注意事項

作者： 源碼筆記
開發 前端
本文主要通過簡單的demo來闡述synchronized鎖的各種用法以及使用synchronized鎖的相關注意事項，記錄下來同時也方便自己記憶。

[[381155]]

本文轉載自微信公眾號「源碼筆記」，作者 源碼筆記 。轉載本文請聯系源碼筆記公眾號。

 1 前言

本文主要通過簡單的demo來闡述synchronized鎖的各種用法以及使用synchronized鎖的相關注意事項，記錄下來同時也方便自己記憶。

synchronized鎖是jvm內置的鎖，不同于ReentrantLock鎖。synchronized關鍵字可以修飾方法，也可以修飾代碼塊。synchronized關鍵字修飾方法時可以修飾靜態方法，也可以修飾非靜態方法;同樣，synchronized關鍵字修飾代碼塊時可以修飾對象，也可以修飾類。當然，synchronized修飾靜態方法/類和非靜態方法/對象時的作用范圍是不同的。下面通過各種demo來詳解synchronized的各種用法及注意事項。

2 synchronized類鎖

這里所說的synchronized類鎖的作用范圍是類級別的，不會因為同一個類的不同對象執行而失效。

2.1 synchronized修飾同一個類的兩個靜態方法時互斥

  1. public class SynchronizeAndClassLock { 
  2.     public static void main(String[] args) throws Exception { 
  3.         new Thread(() -> { 
  4.             // new了一個ClassLock對象 
  5.             new ClassLock().test1(); 
  6.         }).start(); 
  7.  
  8.         new Thread(() -> { 
  9.             // new了另一個ClassLock對象 
  10.             new ClassLock().test2(); 
  11.         }).start(); 
  12.     } 
  13.  
  14. } 
  15. class ClassLock { 
  16.     public synchronized static void test1(){ 
  17.         System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin..."); 
  18.         try { 
  19.             TimeUnit.SECONDS.sleep(1); 
  20.         } catch (Exception e) {} 
  21.         System.out.println(new Date() + " " + Thread.currentThread().getName() + " end..."); 
  22.     } 
  23.  // 【注意】public static void test2(){ 不會互斥，因為此時test2沒有使用類鎖。 
  24.     public synchronized static void test2(){ 
  25.         System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin..."); 
  26.         try { 
  27.             TimeUnit.SECONDS.sleep(1); 
  28.         } catch (Exception e) {} 
  29.         System.out.println(new Date() + " " + Thread.currentThread().getName() + " end..."); 
  30.     } 
  31. } 

運行結果：

【結論】兩個線程分別同時執行同一個類產生的不同對象的兩個不同 synchronized static方法，類鎖生效，雖然是不同對象，因為兩個線程使用的是同一個類鎖。反過來，假如test2方法沒有synchronized修飾的話，只有test1方法有被synchronized修飾，此時兩個方法也不會互斥，一個有鎖，一個沒有鎖，自然不會互斥。

2.2 synchronized分別修飾同一個類的靜態方法和當前類時互斥

  1. public class SynchronizeAndClassLock2 { 
  2.     public static void main(String[] args) throws Exception { 
  3.         new Thread(() -> { 
  4.             // new了一個ClassLock2對象 
  5.             new ClassLock2().test1(); 
  6.             // ClassLock2.test1(); 
  7.         }).start(); 
  8.  
  9.         new Thread(() -> { 
  10.             // new了另一個ClassLock2對象 
  11.             new ClassLock2().test2(); 
  12.             // ClassLock2.test2(); 
  13.         }).start(); 
  14.     } 
  15.  
  16. } 
  17. class ClassLock2 { 
  18.     public synchronized static void test1(){ 
  19.         System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin..."); 
  20.         try { 
  21.             TimeUnit.SECONDS.sleep(1); 
  22.         } catch (Exception e) {} 
  23.         System.out.println(new Date() + " " + Thread.currentThread().getName() + " end..."); 
  24.     } 
  25.  
  26.     public static void test2(){ 
  27.      // 【注意】synchronized (SynchronizeAndClassLock2.class)不會互斥 
  28.         synchronized (ClassLock2.class) { 
  29.             System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin..."); 
  30.             try { 
  31.                 TimeUnit.SECONDS.sleep(1); 
  32.             } catch (Exception e) {} 
  33.             System.out.println(new Date() + " " + Thread.currentThread().getName() + " end..."); 
  34.         } 
  35.     } 
  36. } 

運行結果：

【結論】兩個線程同時分別執行一個被synchronized修飾static方法，一個有synchnized(該類)代碼塊的static方法，鎖生效，雖然是不同對象，因為兩個線程使用的同一個類鎖。反過來，如果是修飾的不同類，因為類鎖不同，肯定不會互斥，比如將test2方法的synchronized (ClassLock2.class)這句代碼改成synchronized (SynchronizeAndClassLock2.class),此時不會互斥。

2.3 synchronized分別修飾同一個靜態對象時互斥

  1. public class SynchronizeAndClassLock10 { 
  2.  
  3.     public static void main(String[] args) throws Exception { 
  4.         new Thread(() -> { 
  5.             new RunObject1().test1(); 
  6.         }).start(); 
  7.  
  8.         new Thread(() -> { 
  9.             new RunObject2().test2(); 
  10.         }).start(); 
  11.     } 
  12. } 
  13.  
  14. class RunObject1 { 
  15.     public static void test1(){ 
  16.      // 【1】synchronized (StaticLock2.staticLock1) { 
  17.         synchronized (StaticLock2.staticLock) { 
  18.             System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin..."); 
  19.             try { 
  20.                 TimeUnit.SECONDS.sleep(1); 
  21.             } catch (Exception e) {} 
  22.             System.out.println(new Date() + " " + Thread.currentThread().getName() + " end..."); 
  23.         } 
  24.     } 
  25. } 
  26.  
  27.  
  28. class RunObject2 { 
  29.     public static void test2() { 
  30.      // 【2】synchronized (StaticLock2.staticLock2) { 
  31.         synchronized (StaticLock2.staticLock) { 
  32.             System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin..."); 
  33.             try { 
  34.                 TimeUnit.SECONDS.sleep(1); 
  35.             } catch (Exception e) {} 
  36.             System.out.println(new Date() + " " + Thread.currentThread().getName() + " end..."); 
  37.         } 
  38.     } 
  39. } 
  40.  
  41. class StaticLock2 { 
  42.     public static Object staticLock = new Object(); 
  43. } 

運行結果：

【結論】synchronized分別修飾同一個類的靜態對象時互斥,反過來，如果是修飾不同的靜態對象，肯定不會互斥，比如將上面代碼中標【1】和【2】的synchronized代碼結合使用。

3 synchronized對象鎖

這里說的synchronized對象鎖的作用范圍是對象級別的即僅僅作用于同一個對象，如果是同一個類的兩個不同的對象是不會互斥的，即沒有效果的。

3.1 synchronized修飾同一個類對象的兩個非靜態方法時互斥

  1. public class SynchronizeAndObjectLock2 { 
  2.     public static void main(String[] args) throws Exception { 
  3.         // 【注意】當且僅當是同一個SynchronizeAndObjectLock2對象 
  4.         SynchronizeAndObjectLock2 synchronizeAndObjectLock2 = new SynchronizeAndObjectLock2(); 
  5.         new Thread(() -> { 
  6.             synchronizeAndObjectLock2.test1(); 
  7.         }).start(); 
  8.  
  9.         new Thread(() -> { 
  10.             synchronizeAndObjectLock2.test2(); 
  11.         }).start(); 
  12.     } 
  13.     public synchronized void test1(){ 
  14.         System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin..."); 
  15.         try { 
  16.             TimeUnit.SECONDS.sleep(1); 
  17.         } catch (Exception e) {} 
  18.         System.out.println(new Date() + " " + Thread.currentThread().getName() + " end..."); 
  19.     } 
  20.  
  21.     public synchronized void test2(){ 
  22.         System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin..."); 
  23.         try { 
  24.             TimeUnit.SECONDS.sleep(1); 
  25.         } catch (Exception e) {} 
  26.         System.out.println(new Date() + " " + Thread.currentThread().getName() + " end..."); 
  27.     } 
  28. } 

運行結果：

【結論】兩個線程同時執行被synchronized修飾的相同對象的不同(相同)方法，鎖生效，因為兩個線程使用的是相同的對象鎖

3.2 synchronized分別修飾同一個類對象的非靜態方法和當前對象時互斥

  1. public class SynchronizeAndObjectLock3 { 
  2.     public static void main(String[] args) throws Exception { 
  3.         // 【注意】當且僅當是同一個SynchronizeAndObjectLock3對象 
  4.         SynchronizeAndObjectLock3 synchronizeAndObjectLock3 = new SynchronizeAndObjectLock3(); 
  5.         new Thread(() -> { 
  6.             synchronizeAndObjectLock3.test1(); 
  7.         }).start(); 
  8.  
  9.         new Thread(() -> { 
  10.             synchronizeAndObjectLock3.test2(); 
  11.         }).start(); 
  12.     } 
  13.     public void test1(){ 
  14.         synchronized(this) { 
  15.             System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin..."); 
  16.             try { 
  17.                 TimeUnit.SECONDS.sleep(1); 
  18.             } catch (Exception e) {} 
  19.             System.out.println(new Date() + " " + Thread.currentThread().getName() + " end..."); 
  20.         } 
  21.  
  22.     } 
  23.  
  24.     public synchronized void test2(){ 
  25.         System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin..."); 
  26.         try { 
  27.             TimeUnit.SECONDS.sleep(1); 
  28.         } catch (Exception e) {} 
  29.         System.out.println(new Date() + " " + Thread.currentThread().getName() + " end..."); 
  30.     } 
  31. } 

運行結果：

【結論】snchronized修飾非靜態方法與synchronized(this)互斥，可見，snchronized修飾非靜態方法實質鎖的是當前對象。

3.3 synchronized修飾不同對象的兩個非靜態方法時不會互斥

  1. public class SynchronizeAndObjectLock { 
  2.     public static void main(String[] args) throws Exception { 
  3.         new Thread(() -> { 
  4.             // 這里new 了一個SynchronizeAndObjectLock對象 
  5.             new SynchronizeAndObjectLock().test1(); 
  6.         }).start(); 
  7.  
  8.         new Thread(() -> { 
  9.             // 這里new 了另一個SynchronizeAndObjectLock對象 
  10.             new SynchronizeAndObjectLock().test2(); 
  11.         }).start(); 
  12.     } 
  13.     public synchronized void test1(){ 
  14.         System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin..."); 
  15.         try { 
  16.             TimeUnit.SECONDS.sleep(1); 
  17.         } catch (Exception e) {} 
  18.         System.out.println(new Date() + " " + Thread.currentThread().getName() + " end..."); 
  19.     } 
  20.  
  21.     public synchronized void test2(){ 
  22.         System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin..."); 
  23.         try { 
  24.             TimeUnit.SECONDS.sleep(1); 
  25.         } catch (Exception e) {} 
  26.         System.out.println(new Date() + " " + Thread.currentThread().getName() + " end..."); 
  27.     } 
  28. } 

運行結果：

【結論】兩個線程同時執行被synchronized修飾的不同對象的不同(相同)方法，鎖未生效，因為兩個線程使用的是不同的對象鎖。

3.4 synchronized代碼塊修飾同一個對象時互斥

  1. public class SynchronizeAndObjectLock5 { 
  2.     private Object objectLock = new Object(); 
  3.  
  4.     public static void main(String[] args) throws Exception { 
  5.          
  6.         SynchronizeAndObjectLock5 synchronizeAndObjectLock5 = new SynchronizeAndObjectLock5(); 
  7.         new Thread(() -> { 
  8.             synchronizeAndObjectLock5.test1(); 
  9.         }).start(); 
  10.  
  11.         new Thread(() -> { 
  12.             synchronizeAndObjectLock5.test2(); 
  13.         }).start(); 
  14.     } 
  15.     public void test1(){ 
  16.         synchronized(objectLock) { 
  17.             System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin..."); 
  18.             try { 
  19.                 TimeUnit.SECONDS.sleep(1); 
  20.             } catch (Exception e) {} 
  21.             System.out.println(new Date() + " " + Thread.currentThread().getName() + " end..."); 
  22.         } 
  23.  
  24.     } 
  25.  
  26.     public void test2(){ 
  27.         synchronized(objectLock) { 
  28.             System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin..."); 
  29.             try { 
  30.                 TimeUnit.SECONDS.sleep(1); 
  31.             } catch (Exception e) {} 
  32.             System.out.println(new Date() + " " + Thread.currentThread().getName() + " end..."); 
  33.         } 
  34.     } 
  35. } 

運行結果：

【結論】synchronized代碼塊修飾同一個對象時互斥，若synchronized代碼塊修飾的是不同對象，那么不會互斥。

4 synchronized修飾當前類和當前對象時不會互斥

  1. public class ClassAndObjectLock { 
  2.     public static void main(String[] args) throws Exception { 
  3.         new Thread(() -> { 
  4.             ClassAndObjectLock.test1(); 
  5.         }).start(); 
  6.  
  7.         new Thread(() -> { 
  8.             new ClassAndObjectLock().test2(); 
  9.         }).start(); 
  10.     } 
  11.     public static void test1(){ 
  12.         synchronized (ClassAndObjectLock.class) { 
  13.             System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin..."); 
  14.             try { 
  15.                 TimeUnit.SECONDS.sleep(1); 
  16.             } catch (Exception e) {} 
  17.             System.out.println(new Date() + " " + Thread.currentThread().getName() + " end..."); 
  18.         } 
  19.     } 
  20.  
  21.     public void test2(){ 
  22.         synchronized (this) { 
  23.             System.out.println(new Date() + " " + Thread.currentThread().getName() + " begin..."); 
  24.             try { 
  25.                 TimeUnit.SECONDS.sleep(1); 
  26.             } catch (Exception e) {} 
  27.             System.out.println(new Date() + " " + Thread.currentThread().getName() + " end..."); 
  28.         } 
  29.     } 
  30. } 

運行結果：

【結論】可見，類鎖和對象鎖是相互獨立的，互不相斥。

5 synchronized鎖注意事項

5.1 synchronized鎖不能被中斷

為了模擬synchronized鎖不可中斷，下面先讓兩個線程進入死鎖，然后再用main線程去中斷其中一個線程，看被中斷的線程能否釋放鎖并被喚醒。

  1. public class DeadLockCannotInterruptDemo { 
  2.     private static Object lock1 = new Object(); 
  3.     private static Object lock2 = new Object(); 
  4.  
  5.     public static void main(String[] args) throws Exception { 
  6.         Thread threadA = new Thread(new Runnable() { 
  7.             @Override 
  8.             public void run() { 
  9.                 synchronized (lock1) { 
  10.                     System.out.println(Thread.currentThread().getName() + " get lock1"); 
  11.                     try { 
  12.                         Thread.sleep(10); 
  13.                         synchronized (lock2) { 
  14.                             System.out.println(Thread.currentThread().getName() + " get lock2"); 
  15.                         } 
  16.                     } catch (InterruptedException e) { 
  17.                         e.printStackTrace(); 
  18.                     } 
  19.                 } 
  20.             } 
  21.         }); 
  22.  
  23.         Thread threadB = new Thread(new Runnable() { 
  24.             @Override 
  25.             public void run() { 
  26.                 synchronized (lock2) { 
  27.                     System.out.println(Thread.currentThread().getName() + " get lock2"); 
  28.                     try { 
  29.                         Thread.sleep(10); 
  30.                         synchronized (lock1) { 
  31.                             System.out.println(Thread.currentThread().getName() + " get lock1"); 
  32.                         } 
  33.                     } catch (InterruptedException e) { 
  34.                         e.printStackTrace(); 
  35.                     } 
  36.                 } 
  37.             } 
  38.         }); 
  39.  
  40.         threadA.start(); 
  41.         threadB.start(); 
  42.  
  43.         TimeUnit.SECONDS.sleep(3); 
  44.         System.out.println("main thread begin to interrupt " + threadA.getName() + " and " + threadA.getName() + " will release lock1..."); 
  45.         threadA.interrupt(); 
  46.     } 
  47. } 

運行結果：

【結論】如上圖，main線程中斷Thread-0后，Thread-0并不會釋放鎖并醒過來。同樣的，ReentrantLock的tryLock或lockInterruptibly是可以被中斷的。

5.2 synchronized鎖可重入

5.2.1 不同方法，synchronized是可重入的

  1. public class SynchronizeAndReentrant { 
  2.     public static void main(String[] args) throws Exception { 
  3.         SynchronizeAndReentrant synchronizeAndReentrant = new SynchronizeAndReentrant(); 
  4.         synchronizeAndReentrant.test1(); 
  5.     } 
  6.     public synchronized void test1(){ 
  7.         System.out.println(" test1 method is called..."); 
  8.         test2(); 
  9.     } 
  10.  
  11.     public synchronized void test2(){ 
  12.         System.out.println(" test2 method is called..."); 
  13.     } 
  14. } 

運行結果：

5.2.2 相同方法，synchronized是可重入的

  1. public class SynchronizeAndReentrant2 { 
  2.     int i = 1; 
  3.     public static void main(String[] args) throws Exception { 
  4.         SynchronizeAndReentrant2 synchronizeAndReentrant = new SynchronizeAndReentrant2(); 
  5.         synchronizeAndReentrant.test1(); 
  6.     } 
  7.     public synchronized void test1(){ 
  8.  
  9.         System.out.println(" test1 method is called " + i++ + "st time..." ); 
  10.         while(i < 5) { 
  11.             test1(); 
  12.         } 
  13.     } 
  14. } 

運行結果：

5.3 synchronized鎖不帶超時功能

synchronized鎖不帶超時功能,而ReentrantLock的tryLock是具備帶超時功能的，在指定時間沒獲取到鎖，該線程會蘇醒，有助于預防死鎖的產生。

5.4 喚醒/等待需要synchronized鎖

  1. public class NotifyNeedSynchronized { 
  2.     public static Object lock = new Object(); 
  3.     public static void main(String[] args) throws Exception{ 
  4.         // 拋出IllegalMonitorStateException 
  5.         //lock.notify(); 
  6.         lock.wait(); 
  7.     } 
  8. } 

運行結果：

【結論】使用Object的notify和wait等方法時，必須要使用synchronized鎖，否則會拋出IllegalMonitorStateException。

5.5 使用synchronized鎖時盡量縮小范圍以保證性能

使用synchronized鎖時，為了盡可能提高性能，我們應該盡量縮小鎖的范圍。能不鎖方法就不鎖方法，推薦盡量使用synchronized代碼塊來降低鎖的范圍。以下面的一段netty源碼為例：

  1. // ServerBootstrap.java 
  2.  
  3. public <T> ServerBootstrap childOption(ChannelOption<T> childOption, T value) { 
  4.     if (childOption == null) { 
  5.         throw new NullPointerException("childOption"); 
  6.     } 
  7.     if (value == null) { 
  8.         synchronized (childOptions) { 
  9.             childOptions.remove(childOption); 
  10.         } 
  11.     } else { 
  12.         synchronized (childOptions) { 
  13.             childOptions.put(childOption, value); 
  14.         } 
  15.     } 
  16.     return this; 
  17. } 

可見，找到并發訪問代碼的臨界區，并不用synchronized鎖全部代碼，盡量避免使用synchronized來修飾方法。

6 總結

本文對synchronized的各種用法及注意事項通過demo簡單梳理了下，后面有時間會探討下synchronized的原理。

 

責任編輯：武曉燕 來源： 源碼筆記
Synchronized鎖用法
相關推薦

2021-12-14 14:50:12

synchronize鎖Java

2011-06-23 11:15:25

SEO網站優化

2009-10-22 14:07:15

布線施工注意事項

2010-06-10 13:11:23

2011-11-23 09:02:57

2011-05-26 11:22:04

SEO

2009-07-15 16:14:36

iBATIS優缺點

2010-05-25 16:46:00

2009-10-10 16:33:29

綜合布線系統

2011-04-14 11:28:07

光纖

2009-11-09 11:01:01

ibmdwPMP

2010-10-29 16:33:45

ORACLE存儲過程

2009-12-03 14:37:47

安裝phpMyAdmi

2009-06-12 09:46:40

Java String

2011-05-19 14:29:50

Oracle存儲語法

2014-01-13 10:50:28

虛擬化存儲

2011-07-22 13:25:10

復印機租賃技巧

2009-12-15 17:47:17

VSIP

2009-10-14 11:23:20

網絡布線系統

2011-03-22 08:56:30

點贊
收藏

51CTO技術棧公眾號

主站蜘蛛池模板： 国产美女视频一区 | 另类在线 | 亚洲欧美在线一区 | 日韩欧美国产精品一区 | 国产视频一视频二 | 欧美日韩高清一区二区三区 | 99热这里有精品 | 欧美黄在线观看 | 国产在线高清 | 成人av片在线观看 | 中文字幕成人在线 | 成人久久18免费网站图片 | 91精品一区 | 暖暖日本在线视频 | 欧美最猛黑人xxxⅹ 粉嫩一区二区三区四区公司1 | 亚洲成人精品一区 | 91传媒在线播放 | 久草在线影 | 国产精品国产三级国产aⅴ无密码 | 国产精品久久av | 国产午夜精品一区二区三区在线观看 | 亚洲在线视频 | 国产精品久久国产精品 | 亚洲精品视频免费看 | 国产999精品久久久久久绿帽 | 成人免费观看视频 | 女生羞羞视频 | 亚洲精品乱码久久久久久黑人 | 久久久精品国产 | 国产成人精品一区二三区在线观看 | 免费国产一区二区 | 欧美一级在线视频 | 日韩久久中文字幕 | 亚洲欧美综合精品久久成人 | 欧美区在线 | 播放一级黄色片 | 欧美视频 亚洲视频 | 精品久久成人 | 国产国产精品久久久久 | 精品久久久久久久 | 国产一区三区视频 |