Java多線程系列--「基礎篇」04之 synchronized關鍵字
概要
本章，會對synchronized關鍵字進行介紹。涉及到的內容包括：
1. synchronized原理
2. synchronized基本規則
3. synchronized方法 和 synchronized代碼塊
4. 實例鎖 和 全局鎖html
轉載請註明出處：http://www.cnblogs.com/skywang12345/p/3479202.htmljava
1. synchronized原理
在java中，每個對象有且僅有一個同步鎖。這也意味着，同步鎖是依賴於對象而存在。
當咱們調用某對象的synchronized方法時，就獲取了該對象的同步鎖。例如，synchronized(obj)就獲取了「obj這個對象」的同步鎖。
不一樣線程對同步鎖的訪問是互斥的。也就是說，某時間點，對象的同步鎖只能被一個線程獲取到！經過同步鎖，咱們就能在多線程中，實現對「對象/方法」的互斥訪問。 例如，如今有兩個線程A和線程B，它們都會訪問「對象obj的同步鎖」。假設，在某一時刻，線程A獲取到「obj的同步鎖」並在執行一些操做；而此時，線程B也企圖獲取「obj的同步鎖」 —— 線程B會獲取失敗，它必須等待，直到線程A釋放了「該對象的同步鎖」以後線程B才能獲取到「obj的同步鎖」從而才能夠運行。多線程
2. synchronized基本規則
咱們將synchronized的基本規則總結爲下面3條，並經過實例對它們進行說明。
第一條: 當一個線程訪問「某對象」的「synchronized方法」或者「synchronized代碼塊」時，其餘線程對「該對象」的該「synchronized方法」或者「synchronized代碼塊」的訪問將被阻塞。
第二條: 當一個線程訪問「某對象」的「synchronized方法」或者「synchronized代碼塊」時，其餘線程仍然能夠訪問「該對象」的非同步代碼塊。
第三條: 當一個線程訪問「某對象」的「synchronized方法」或者「synchronized代碼塊」時，其餘線程對「該對象」的其餘的「synchronized方法」或者「synchronized代碼塊」的訪問將被阻塞。ide
第一條
當一個線程訪問「某對象」的「synchronized方法」或者「synchronized代碼塊」時，其餘線程對「該對象」的該「synchronized方法」或者「synchronized代碼塊」的訪問將被阻塞。
下面是「synchronized代碼塊」對應的演示程序。oop
1 class MyRunable implements Runnable { 2 3 @Override 4 public void run() { 5 synchronized(this) { 6 try { 7 for (int i = 0; i < 5; i++) { 8 Thread.sleep(100); // 休眠100ms 9 System.out.println(Thread.currentThread().getName() + " loop " + i); 10 } 11 } catch (InterruptedException ie) { 12 } 13 } 14 } 15 } 16 17 public class Demo1_1 { 18 19 public static void main(String[] args) { 20 Runnable demo = new MyRunable(); // 新建「Runnable對象」 21 22 Thread t1 = new Thread(demo, "t1"); // 新建「線程t1」, t1是基於demo這個Runnable對象 23 Thread t2 = new Thread(demo, "t2"); // 新建「線程t2」, t2是基於demo這個Runnable對象 24 t1.start(); // 啓動「線程t1」 25 t2.start(); // 啓動「線程t2」 26 } 27 }
運行結果：this
t1 loop 0 t1 loop 1 t1 loop 2 t1 loop 3 t1 loop 4 t2 loop 0 t2 loop 1 t2 loop 2 t2 loop 3 t2 loop 4
結果說明：
run()方法中存在「synchronized(this)代碼塊」，並且t1和t2都是基於"demo這個Runnable對象"建立的線程。這就意味着，咱們能夠將synchronized(this)中的this看做是「demo這個Runnable對象」；所以，線程t1和t2共享「demo對象的同步鎖」。因此，當一個線程運行的時候，另一個線程必須等待「運行線程」釋放「demo的同步鎖」以後才能運行。spa
若是你確認，你搞清楚這個問題了。那咱們將上面的代碼進行修改，而後再運行看看結果怎麼樣，看看你是否會迷糊。修改後的源碼以下：線程
1 class MyThread extends Thread { 2 3 public MyThread(String name) { 4 super(name); 5 } 6 7 @Override 8 public void run() { 9 synchronized(this) { 10 try { 11 for (int i = 0; i < 5; i++) { 12 Thread.sleep(100); // 休眠100ms 13 System.out.println(Thread.currentThread().getName() + " loop " + i); 14 } 15 } catch (InterruptedException ie) { 16 } 17 } 18 } 19 } 20 21 public class Demo1_2 { 22 23 public static void main(String[] args) { 24 Thread t1 = new MyThread("t1"); // 新建「線程t1」 25 Thread t2 = new MyThread("t2"); // 新建「線程t2」 26 t1.start(); // 啓動「線程t1」 27 t2.start(); // 啓動「線程t2」 28 } 29 }
代碼說明：
比較Demo1_2 和 Demo1_1，咱們發現，Demo1_2中的MyThread類是直接繼承於Thread，並且t1和t2都是MyThread子線程。
幸運的是，在「Demo1_2的run()方法」也調用了synchronized(this)，正如「Demo1_1的run()方法」也調用了synchronized(this)同樣！
那麼，Demo1_2的執行流程是否是和Demo1_1同樣呢？
運行結果：code
t1 loop 0 t2 loop 0 t1 loop 1 t2 loop 1 t1 loop 2 t2 loop 2 t1 loop 3 t2 loop 3 t1 loop 4 t2 loop 4
結果說明：
若是這個結果一點也不令你感到驚訝，那麼我相信你對synchronized和this的認識已經比較深入了。不然的話，請繼續閱讀這裏的分析。
synchronized(this)中的this是指「當前的類對象」，即synchronized(this)所在的類對應的當前對象。它的做用是獲取「當前對象的同步鎖」。
對於Demo1_2中，synchronized(this)中的this表明的是MyThread對象，而t1和t2是兩個不一樣的MyThread對象，所以t1和t2在執行synchronized(this)時，獲取的是不一樣對象的同步鎖。對於Demo1_1對而言，synchronized(this)中的this表明的是MyRunable對象；t1和t2共同一個MyRunable對象，所以，一個線程獲取了對象的同步鎖，會形成另一個線程等待。htm
第二條
當一個線程訪問「某對象」的「synchronized方法」或者「synchronized代碼塊」時，其餘線程仍然能夠訪問「該對象」的非同步代碼塊。
下面是「synchronized代碼塊」對應的演示程序。
1 class Count { 2 3 // 含有synchronized同步塊的方法 4 public void synMethod() { 5 synchronized(this) { 6 try { 7 for (int i = 0; i < 5; i++) { 8 Thread.sleep(100); // 休眠100ms 9 System.out.println(Thread.currentThread().getName() + " synMethod loop " + i); 10 } 11 } catch (InterruptedException ie) { 12 } 13 } 14 } 15 16 // 非同步的方法 17 public void nonSynMethod() { 18 try { 19 for (int i = 0; i < 5; i++) { 20 Thread.sleep(100); 21 System.out.println(Thread.currentThread().getName() + " nonSynMethod loop " + i); 22 } 23 } catch (InterruptedException ie) { 24 } 25 } 26 } 27 28 public class Demo2 { 29 30 public static void main(String[] args) { 31 final Count count = new Count(); 32 // 新建t1, t1會調用「count對象」的synMethod()方法 33 Thread t1 = new Thread( 34 new Runnable() { 35 @Override 36 public void run() { 37 count.synMethod(); 38 } 39 }, "t1"); 40 41 // 新建t2, t2會調用「count對象」的nonSynMethod()方法 42 Thread t2 = new Thread( 43 new Runnable() { 44 @Override 45 public void run() { 46 count.nonSynMethod(); 47 } 48 }, "t2"); 49 50 51 t1.start(); // 啓動t1 52 t2.start(); // 啓動t2 53 } 54 }
運行結果：
t1 synMethod loop 0 t2 nonSynMethod loop 0 t1 synMethod loop 1 t2 nonSynMethod loop 1 t1 synMethod loop 2 t2 nonSynMethod loop 2 t1 synMethod loop 3 t2 nonSynMethod loop 3 t1 synMethod loop 4 t2 nonSynMethod loop 4
結果說明：
主線程中新建了兩個子線程t1和t2。t1會調用count對象的synMethod()方法，該方法內含有同步塊；而t2則會調用count對象的nonSynMethod()方法，該方法不是同步方法。t1運行時，雖然調用synchronized(this)獲取「count的同步鎖」；可是並無形成t2的阻塞，由於t2沒有用到「count」同步鎖。
第三條
當一個線程訪問「某對象」的「synchronized方法」或者「synchronized代碼塊」時，其餘線程對「該對象」的其餘的「synchronized方法」或者「synchronized代碼塊」的訪問將被阻塞。
咱們將上面的例子中的nonSynMethod()方法體的也用synchronized(this)修飾。修改後的源碼以下：
1 class Count { 2 3 // 含有synchronized同步塊的方法 4 public void synMethod() { 5 synchronized(this) { 6 try { 7 for (int i = 0; i < 5; i++) { 8 Thread.sleep(100); // 休眠100ms 9 System.out.println(Thread.currentThread().getName() + " synMethod loop " + i); 10 } 11 } catch (InterruptedException ie) { 12 } 13 } 14 } 15 16 // 也包含synchronized同步塊的方法 17 public void nonSynMethod() { 18 synchronized(this) { 19 try { 20 for (int i = 0; i < 5; i++) { 21 Thread.sleep(100); 22 System.out.println(Thread.currentThread().getName() + " nonSynMethod loop " + i); 23 } 24 } catch (InterruptedException ie) { 25 } 26 } 27 } 28 } 29 30 public class Demo3 { 31 32 public static void main(String[] args) { 33 final Count count = new Count(); 34 // 新建t1, t1會調用「count對象」的synMethod()方法 35 Thread t1 = new Thread( 36 new Runnable() { 37 @Override 38 public void run() { 39 count.synMethod(); 40 } 41 }, "t1"); 42 43 // 新建t2, t2會調用「count對象」的nonSynMethod()方法 44 Thread t2 = new Thread( 45 new Runnable() { 46 @Override 47 public void run() { 48 count.nonSynMethod(); 49 } 50 }, "t2"); 51 52 53 t1.start(); // 啓動t1 54 t2.start(); // 啓動t2 55 } 56 }
運行結果：
t1 synMethod loop 0 t1 synMethod loop 1 t1 synMethod loop 2 t1 synMethod loop 3 t1 synMethod loop 4 t2 nonSynMethod loop 0 t2 nonSynMethod loop 1 t2 nonSynMethod loop 2 t2 nonSynMethod loop 3 t2 nonSynMethod loop 4
結果說明：
主線程中新建了兩個子線程t1和t2。t1和t2運行時都調用synchronized(this)，這個this是Count對象(count)，而t1和t2共用count。所以，在t1運行時，t2會被阻塞，等待t1運行釋放「count對象的同步鎖」，t2才能運行。
3. synchronized方法 和 synchronized代碼塊
「synchronized方法」是用synchronized修飾方法，而 「synchronized代碼塊」則是用synchronized修飾代碼塊。
synchronized方法示例
public synchronized void foo1() { System.out.println("synchronized methoed"); }
synchronized代碼塊
public void foo2() { synchronized (this) { System.out.println("synchronized methoed"); } }
synchronized代碼塊中的this是指當前對象。也能夠將this替換成其餘對象，例如將this替換成obj，則foo2()在執行synchronized(obj)時就獲取的是obj的同步鎖。
synchronized代碼塊能夠更精確的控制衝突限制訪問區域，有時候表現更高效率。下面經過一個示例來演示：
1 // Demo4.java的源碼 2 public class Demo4 { 3 4 public synchronized void synMethod() { 5 for(int i=0; i<1000000; i++) 6 ; 7 } 8 9 public void synBlock() { 10 synchronized( this ) { 11 for(int i=0; i<1000000; i++) 12 ; 13 } 14 } 15 16 public static void main(String[] args) { 17 Demo4 demo = new Demo4(); 18 19 long start, diff; 20 start = System.currentTimeMillis(); // 獲取當前時間(millis) 21 demo.synMethod(); // 調用「synchronized方法」 22 diff = System.currentTimeMillis() - start; // 獲取「時間差值」 23 System.out.println("synMethod() : "+ diff); 24 25 start = System.currentTimeMillis(); // 獲取當前時間(millis) 26 demo.synBlock(); // 調用「synchronized方法塊」 27 diff = System.currentTimeMillis() - start; // 獲取「時間差值」 28 System.out.println("synBlock() : "+ diff); 29 } 30 }
(某一次)執行結果：
synMethod() : 11
synBlock() : 3
4. 實例鎖 和 全局鎖
實例鎖 -- 鎖在某一個實例對象上。若是該類是單例，那麼該鎖也具備全局鎖的概念。
實例鎖對應的就是synchronized關鍵字。
全局鎖 -- 該鎖針對的是類，不管實例多少個對象，那麼線程都共享該鎖。
全局鎖對應的就是static synchronized（或者是鎖在該類的class或者classloader對象上）。
關於「實例鎖」和「全局鎖」有一個很形象的例子：
pulbic class Something { public synchronized void isSyncA(){} public synchronized void isSyncB(){} public static synchronized void cSyncA(){} public static synchronized void cSyncB(){} }
假設，Something有兩個實例x和y。分析下面4組表達式獲取的鎖的狀況。
(01) x.isSyncA()與x.isSyncB()
(02) x.isSyncA()與y.isSyncA()
(03) x.cSyncA()與y.cSyncB()
(04) x.isSyncA()與Something.cSyncA()
(01) 不能被同時訪問。由於isSyncA()和isSyncB()都是訪問同一個對象(對象x)的同步鎖！
1 // LockTest1.java的源碼 2 class Something { 3 public synchronized void isSyncA(){ 4 try { 5 for (int i = 0; i < 5; i++) { 6 Thread.sleep(100); // 休眠100ms 7 System.out.println(Thread.currentThread().getName()+" : isSyncA"); 8 } 9 }catch (InterruptedException ie) { 10 } 11 } 12 public synchronized void isSyncB(){ 13 try { 14 for (int i = 0; i < 5; i++) { 15 Thread.sleep(100); // 休眠100ms 16 System.out.println(Thread.currentThread().getName()+" : isSyncB"); 17 } 18 }catch (InterruptedException ie) { 19 } 20 } 21 } 22 23 public class LockTest1 { 24 25 Something x = new Something(); 26 Something y = new Something(); 27 28 // 比較(01) x.isSyncA()與x.isSyncB() 29 private void test1() { 30 // 新建t11, t11會調用 x.isSyncA() 31 Thread t11 = new Thread( 32 new Runnable() { 33 @Override 34 public void run() { 35 x.isSyncA(); 36 } 37 }, "t11"); 38 39 // 新建t12, t12會調用 x.isSyncB() 40 Thread t12 = new Thread( 41 new Runnable() { 42 @Override 43 public void run() { 44 x.isSyncB(); 45 } 46 }, "t12"); 47 48 49 t11.start(); // 啓動t11 50 t12.start(); // 啓動t12 51 } 52 53 public static void main(String[] args) { 54 LockTest1 demo = new LockTest1(); 55 demo.test1(); 56 } 57 }
運行結果：
t11 : isSyncA
t11 : isSyncA
t11 : isSyncA
t11 : isSyncA
t11 : isSyncA
t12 : isSyncB
t12 : isSyncB
t12 : isSyncB
t12 : isSyncB
t12 : isSyncB
(02) 能夠同時被訪問。由於訪問的不是同一個對象的同步鎖，x.isSyncA()訪問的是x的同步鎖，而y.isSyncA()訪問的是y的同步鎖。
1 // LockTest2.java的源碼 2 class Something { 3 public synchronized void isSyncA(){ 4 try { 5 for (int i = 0; i < 5; i++) { 6 Thread.sleep(100); // 休眠100ms 7 System.out.println(Thread.currentThread().getName()+" : isSyncA"); 8 } 9 }catch (InterruptedException ie) { 10 } 11 } 12 public synchronized void isSyncB(){ 13 try { 14 for (int i = 0; i < 5; i++) { 15 Thread.sleep(100); // 休眠100ms 16 System.out.println(Thread.currentThread().getName()+" : isSyncB"); 17 } 18 }catch (InterruptedException ie) { 19 } 20 } 21 public static synchronized void cSyncA(){ 22 try { 23 for (int i = 0; i < 5; i++) { 24 Thread.sleep(100); // 休眠100ms 25 System.out.println(Thread.currentThread().getName()+" : cSyncA"); 26 } 27 }catch (InterruptedException ie) { 28 } 29 } 30 public static synchronized void cSyncB(){ 31 try { 32 for (int i = 0; i < 5; i++) { 33 Thread.sleep(100); // 休眠100ms 34 System.out.println(Thread.currentThread().getName()+" : cSyncB"); 35 } 36 }catch (InterruptedException ie) { 37 } 38 } 39 } 40 41 public class LockTest2 { 42 43 Something x = new Something(); 44 Something y = new Something(); 45 46 // 比較(02) x.isSyncA()與y.isSyncA() 47 private void test2() { 48 // 新建t21, t21會調用 x.isSyncA() 49 Thread t21 = new Thread( 50 new Runnable() { 51 @Override 52 public void run() { 53 x.isSyncA(); 54 } 55 }, "t21"); 56 57 // 新建t22, t22會調用 x.isSyncB() 58 Thread t22 = new Thread( 59 new Runnable() { 60 @Override 61 public void run() { 62 y.isSyncA(); 63 } 64 }, "t22"); 65 66 67 t21.start(); // 啓動t21 68 t22.start(); // 啓動t22 69 } 70 71 public static void main(String[] args) { 72 LockTest2 demo = new LockTest2(); 73 74 demo.test2(); 75 } 76 }
運行結果：
t21 : isSyncA
t22 : isSyncA
t21 : isSyncA
t22 : isSyncA
t21 : isSyncA
t22 : isSyncA
t21 : isSyncA
t22 : isSyncA
t21 : isSyncA
t22 : isSyncA
(03) 不能被同時訪問。由於cSyncA()和cSyncB()都是static類型，x.cSyncA()至關於Something.isSyncA()，y.cSyncB()至關於Something.isSyncB()，所以它們共用一個同步鎖，不能被同時反問。
1 // LockTest3.java的源碼 2 class Something { 3 public synchronized void isSyncA(){ 4 try { 5 for (int i = 0; i < 5; i++) { 6 Thread.sleep(100); // 休眠100ms 7 System.out.println(Thread.currentThread().getName()+" : isSyncA"); 8 } 9 }catch (InterruptedException ie) { 10 } 11 } 12 public synchronized void isSyncB(){ 13 try { 14 for (int i = 0; i < 5; i++) { 15 Thread.sleep(100); // 休眠100ms 16 System.out.println(Thread.currentThread().getName()+" : isSyncB"); 17 } 18 }catch (InterruptedException ie) { 19 } 20 } 21 public static synchronized void cSyncA(){ 22 try { 23 for (int i = 0; i < 5; i++) { 24 Thread.sleep(100); // 休眠100ms 25 System.out.println(Thread.currentThread().getName()+" : cSyncA"); 26 } 27 }catch (InterruptedException ie) { 28 } 29 } 30 public static synchronized void cSyncB(){ 31 try { 32 for (int i = 0; i < 5; i++) { 33 Thread.sleep(100); // 休眠100ms 34 System.out.println(Thread.currentThread().getName()+" : cSyncB"); 35 } 36 }catch (InterruptedException ie) { 37 } 38 } 39 } 40 41 public class LockTest3 { 42 43 Something x = new Something(); 44 Something y = new Something(); 45 46 // 比較(03) x.cSyncA()與y.cSyncB() 47 private void test3() { 48 // 新建t31, t31會調用 x.isSyncA() 49 Thread t31 = new Thread( 50 new Runnable() { 51 @Override 52 public void run() { 53 x.cSyncA(); 54 } 55 }, "t31"); 56 57 // 新建t32, t32會調用 x.isSyncB() 58 Thread t32 = new Thread( 59 new Runnable() { 60 @Override 61 public void run() { 62 y.cSyncB(); 63 } 64 }, "t32"); 65 66 67 t31.start(); // 啓動t31 68 t32.start(); // 啓動t32 69 } 70 71 public static void main(String[] args) { 72 LockTest3 demo = new LockTest3(); 73 74 demo.test3(); 75 } 76 }
運行結果：
t31 : cSyncA
t31 : cSyncA
t31 : cSyncA
t31 : cSyncA
t31 : cSyncA
t32 : cSyncB
t32 : cSyncB
t32 : cSyncB
t32 : cSyncB
t32 : cSyncB
(04) 能夠被同時訪問。由於isSyncA()是實例方法，x.isSyncA()使用的是對象x的鎖；而cSyncA()是靜態方法，Something.cSyncA()能夠理解對使用的是「類的鎖」。所以，它們是能夠被同時訪問的。
1 // LockTest4.java的源碼 2 class Something { 3 public synchronized void isSyncA(){ 4 try { 5 for (int i = 0; i < 5; i++) { 6 Thread.sleep(100); // 休眠100ms 7 System.out.println(Thread.currentThread().getName()+" : isSyncA"); 8 } 9 }catch (InterruptedException ie) { 10 } 11 } 12 public synchronized void isSyncB(){ 13 try { 14 for (int i = 0; i < 5; i++) { 15 Thread.sleep(100); // 休眠100ms 16 System.out.println(Thread.currentThread().getName()+" : isSyncB"); 17 } 18 }catch (InterruptedException ie) { 19 } 20 } 21 public static synchronized void cSyncA(){ 22 try { 23 for (int i = 0; i < 5; i++) { 24 Thread.sleep(100); // 休眠100ms 25 System.out.println(Thread.currentThread().getName()+" : cSyncA"); 26 } 27 }catch (InterruptedException ie) { 28 } 29 } 30 public static synchronized void cSyncB(){ 31 try { 32 for (int i = 0; i < 5; i++) { 33 Thread.sleep(100); // 休眠100ms 34 System.out.println(Thread.currentThread().getName()+" : cSyncB"); 35 } 36 }catch (InterruptedException ie) { 37 } 38 } 39 } 40 41 public class LockTest4 { 42 43 Something x = new Something(); 44 Something y = new Something(); 45 46 // 比較(04) x.isSyncA()與Something.cSyncA() 47 private void test4() { 48 // 新建t41, t41會調用 x.isSyncA() 49 Thread t41 = new Thread( 50 new Runnable() { 51 @Override 52 public void run() { 53 x.isSyncA(); 54 } 55 }, "t41"); 56 57 // 新建t42, t42會調用 x.isSyncB() 58 Thread t42 = new Thread( 59 new Runnable() { 60 @Override 61 public void run() { 62 Something.cSyncA(); 63 } 64 }, "t42"); 65 66 67 t41.start(); // 啓動t41 68 t42.start(); // 啓動t42 69 } 70 71 public static void main(String[] args) { 72 LockTest4 demo = new LockTest4(); 73 74 demo.test4(); 75 } 76 }
運行結果：
t41 : isSyncA
t42 : cSyncA
t41 : isSyncA
t42 : cSyncA
t41 : isSyncA
t42 : cSyncA
t41 : isSyncA
t42 : cSyncA
t41 : isSyncA
t42 : cSyncA
更多內容
- 1. 多線程「基礎篇」04之 synchronized關鍵字
- 2. Java多線程基礎篇（03）-synchronized關鍵字
- 3. Java多線程系列之synchronized關鍵字解析
- 4. Java多線程之synchronized&volatile基礎篇
- 5. 多線程---Synchronized關鍵字
- 6. [多線程] Synchronized 關鍵字
- 7. Java多線程系列--「基礎篇」07之 線程休眠
- 8. 04之 synchronized關鍵字
- 9. Java多線程系列--「基礎篇」06之 線程讓步
- 10. Java 多線程：關鍵字 synchronized 和 volatile
- 更多相關文章...
- • C# 多線程 - C#教程
- • SQLite Distinct 關鍵字 - SQLite教程
- • Java 8 Stream 教程
- • NewSQL-TiDB相關
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 多線程「基礎篇」04之 synchronized關鍵字
- 2. Java多線程基礎篇（03）-synchronized關鍵字
- 3. Java多線程系列之synchronized關鍵字解析
- 4. Java多線程之synchronized&volatile基礎篇
- 5. 多線程---Synchronized關鍵字
- 6. [多線程] Synchronized 關鍵字
- 7. Java多線程系列--「基礎篇」07之 線程休眠
- 8. 04之 synchronized關鍵字
- 9. Java多線程系列--「基礎篇」06之 線程讓步
- 10. Java 多線程：關鍵字 synchronized 和 volatile