在并發(fā)編程中，經(jīng)常遇到多個線程訪問同一個 共享資源 ，這時候作為開發(fā)者必須考慮如何維護數(shù)據(jù)一致性，在java中synchronized關(guān)鍵字被常用于維護數(shù)據(jù)一致性。synchronized機制是給共享資源上鎖，只有拿到鎖的線程才可以訪問共享資源，這樣就可以強制使得對共享資源的訪問都是順序的，因為對于共享資源屬性訪問是必要也是必須的，下文會有具體示例演示。
一.java中的鎖
一般在java中所說的鎖就是指的內(nèi)置鎖，每個java對象都可以作為一個實現(xiàn)同步的鎖，雖然說在java中一切皆對象， 但是鎖必須是引用類型的，基本數(shù)據(jù)類型則不可以 。每一個引用類型的對象都可以隱式的扮演一個用于同步的鎖的角色，執(zhí)行線程進入synchronized塊之前會自動獲得鎖，無論是通過正常語句退出還是執(zhí)行過程中拋出了異常，線程都會在放棄對synchronized塊的控制時自動釋放鎖。 獲得鎖的唯一途徑就是進入這個內(nèi)部鎖保護的同步塊或方法 。
正如引言中所說，對共享資源的訪問必須是順序的，也就是說當多個線程對共享資源訪問的時候，只能有一個線程可以獲得該共享資源的鎖，當線程A嘗試獲取線程B的鎖時，線程A必須等待或者阻塞，直到線程B釋放該鎖為止，否則線程A將一直等待下去，因此java內(nèi)置鎖也稱作互斥鎖，也即是說鎖實際上是一種互斥機制。
根據(jù)使用方式的不同一般我們會將鎖分為對象鎖和類鎖，兩個鎖是有很大差別的，對象鎖是作用在實例方法或者一個對象實例上面的，而類鎖是作用在靜態(tài)方法或者Class對象上面的。一個類可以有多個實例對象，因此一個類的對象鎖可能會有多個，但是每個類只有一個Class對象，所以類鎖只有一個。 類鎖只是一個概念上的東西，并不是真實存在的，它只是用來幫助我們理解鎖定的是實例方法還是靜態(tài)方法區(qū)別的 。
在java中實現(xiàn)鎖機制不僅僅限于使用synchronized關(guān)鍵字，還有JDK1.5之后提供的Lock，Lock不在本文討論范圍之內(nèi)。一個synchronized塊包含兩個部分：鎖對象的引用，以及這個鎖保護的代碼塊。如果作用在實例方法上面，鎖就是該方法所在的當前對象，靜態(tài)synchronized方法會從Class對象上獲得鎖。
二.synchronized使用示例
1.多窗口售票
假設(shè)一個火車票售票系統(tǒng)，有若干個窗口同時售票，很顯然在這里票是作為多個窗口的共享資源存在的，由于座位號是確定的，因此票上面的號碼也是確定的，我們用多個線程來模擬多個窗口同時售票，首先在不使用synchronized關(guān)鍵字的情況下測試一下售票情況。
先將票本身作為一個共享資源放在單獨的線程中，這種作為共享資源存在的線程很顯然應(yīng)該是實現(xiàn)Runnable接口，我們將票的總數(shù)num作為一個入?yún)魅耄看紊梢粋€票之后將num做減法運算，直至num為0即停止，說明票已經(jīng)售完了，然后開啟多個線程將票資源傳入。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
public class Ticket implements Runnable{ private int num;//票數(shù)量 private boolean flag=true;//若為false則售票停止 public Ticket(int num){ this.num=num; } @Override public void run() { while(flag){ ticket(); } } private void ticket(){ if(num<=0){ flag=false; return; } try { Thread.sleep(20);//模擬延時操作 } catch (InterruptedException e) { e.printStackTrace(); } //輸出當前窗口號以及出票序列號 System.out.println(Thread.currentThread().getName()+"售出票序列號："+num--); } } public class MainTest { public static void main(String[] args) { Ticketticket = new Ticket(5); Threadwindow01 = new Thread(ticket, "窗口01"); Threadwindow02 = new Thread(ticket, "窗口02"); Threadwindow03 = new Thread(ticket, "窗口03"); window01.start(); window02.start(); window03.start(); } } |
程序的輸出結(jié)果如下：
|
1
2
3
4
5
6
7
8
9
|
窗口02售出票序列號：5窗口03售出票序列號：4窗口01售出票序列號：5窗口02售出票序列號：3窗口01售出票序列號：2窗口03售出票序列號：2窗口02售出票序列號：1窗口03售出票序列號：0窗口01售出票序列號：-1 |
從上面程序運行結(jié)果可以看出不但票的序號有重號而且出票數(shù)量也不對，這種售票系統(tǒng)比12306可要爛多了，人家在繁忙的時候只是刷不到票而已，而這里的售票系統(tǒng)倒好了，出票比預(yù)計的多了而且會出現(xiàn)多個人爭搶做同一個座位的風險。如果是單個售票窗口是不會出現(xiàn)這種問題，多窗口同時售票就會出現(xiàn)爭搶共享資源因此紊亂的現(xiàn)象，解決該現(xiàn)象也很簡單，就是在ticket()方法前面加上synchronized關(guān)鍵字或者將ticket()方法的方法體完全用synchronized塊包括起來。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
//方式一 private synchronized void ticket(){ if(num<=0){ flag=false; return; } try { Thread.sleep(20);//模擬延時操作 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+"售出票序列號："+num--); } //方式二 private void ticket(){ synchronized (this) { if (num <= 0) { flag = false; return; } try { Thread.sleep(20);//模擬延時操作 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "售出票序列號：" + num--); } } |
再看一下加入synchronized關(guān)鍵字的程序運行結(jié)果：
|
1
2
3
4
5
|
窗口01售出票序列號：5窗口03售出票序列號：4窗口03售出票序列號：3窗口02售出票序列號：2窗口02售出票序列號：1 |
從這里可以看出在實例方法上面加上synchronized關(guān)鍵字的實現(xiàn)效果跟對整個方法體加上synchronized效果是一樣的。 另外一點需要注意加鎖的時機也非常重要 ，本示例中ticket()方法中有兩處操作容易出現(xiàn)紊亂，一個是在if語句模塊，一處是在num–，這兩處操作本身都不是原子類型的操作，但是在使用運行的時候需要這兩處當成一個整體操作，所以synchronized將整個方法體都包裹在了一起。如若不然，假設(shè)num當前值是1，但是窗口01執(zhí)行到了num–，整個操作還沒執(zhí)行完成，只進行了賦值運算還沒進行自減運算，但是窗口02已經(jīng)進入到了if語句模塊，此時num還是等于1，等到窗口02執(zhí)行到了輸出語句的時候，窗口01的num–也已經(jīng)將自減運算執(zhí)行完成，這時候窗口02就會輸出序列號0的票。再者如果將synchronized關(guān)鍵字加在了run方法上面，這時候的操作不會出現(xiàn)紊亂或者錯誤，但是這種加鎖方式無異于單窗口操作，當窗口01拿到鎖進入run()方法之后,必須等到flag為false才會將語句執(zhí)行完成跳出循環(huán)，這時候的num就已經(jīng)為0了，也就是說票已經(jīng)被售賣完了，這種方式摒棄了多線程操作，違背了最初的設(shè)計原則-多窗口售票。
2.懶漢式單例模式
創(chuàng)建單例模式有很多中實現(xiàn)方式，本文只討論懶漢式創(chuàng)建。在Android開發(fā)過程中單例模式可以說是最常使用的一種設(shè)計模式，因為它操作簡單還可以有效減少內(nèi)存溢出。下面是懶漢式創(chuàng)建單例模式一個示例：
|
1
2
3
4
5
6
7
8
9
10
11
|
public class Singleton { private static Singletoninstance; private Singleton() { } public static SingletongetInstance() { if (instance == null) { instance = new Singleton(); } return instance; } } |
如果對于多窗口售票邏輯已經(jīng)完全明白了的話就可以看出這里的實現(xiàn)方式是有問題的，我們可以簡單的創(chuàng)建幾個線程來獲取單例輸出對象的hascode值。
|
1
2
3
|
com.sunny.singleton.Singleton@15c330aacom.sunny.singleton.Singleton@15c330aacom.sunny.singleton.Singleton@41aff40f |
在多線程模式下發(fā)現(xiàn)會出現(xiàn)不同的對象，這種單例模式很顯然不是我們想要的，那么根據(jù)上面多窗口售票的邏輯我們在getInstance()方法上面加上一個synchronized關(guān)鍵字，給該方法加上鎖，加上鎖之后可以避免多線程模式下生成多個不同對象，但是同樣會帶來一個效率問題，因為不管哪個線性進入getInstance()方法都會先獲得鎖，然后再次釋放鎖，這是一個方面，另一個方面就是只有在第一次調(diào)用getInstance()方法的時候，也就是在if語句塊內(nèi)才會出現(xiàn)多線程并發(fā)問題，而我們卻索性將整個方法都上鎖了。討論到這里就引出了另外一個問題，究竟是synchronized方法好還是synchronized代碼塊好呢？ 有一個原則就是鎖的范圍越小越好 ，加鎖的目的就是將鎖進去的代碼作為原子性操作,因為非原子操作都不是線程安全的，因此synchronized代碼塊應(yīng)該是在開發(fā)過程中優(yōu)先考慮使用的加鎖方式。
|
1
2
3
4
5
6
7
8
|
public static SingletongetInstance() { if (instance == null) { synchronized (Singleton.class) { instance = new Singleton(); } } return instance; } |
這里也會遇到類似上面的問題，多線程并發(fā)下回生成多個實例，如線程A和線程B都進入if語句塊，假設(shè)線程A先獲得鎖，線程B則等待，當new一個實例后，線程A釋放鎖，線程B獲得鎖后會再次執(zhí)行new語句，同樣不能保證單例要求，那么下面代碼再來一個null判斷，進行雙重檢查上鎖呢？
|
1
2
3
4
5
6
7
8
9
10
|
public static SingletongetInstance() { if (instance == null) { synchronized (Singleton.class) { if(instance==null){ instance = new Singleton(); } } } return instance; } |
該模式就是雙重檢查上鎖實現(xiàn)的單例模式，這里在代碼層面我們已經(jīng) 基本 保證了線程安全了,但是還是有問題的， 雙重檢查鎖定的問題是：并不能保證它會在單處理器或多處理器計算機上順利運行。雙重檢查鎖定失敗的問題并不歸咎于 JVM 中的實現(xiàn)bug，而是歸咎于java平臺內(nèi)存模型。內(nèi)存模型允許所謂的“無序?qū)懭?rdquo;，這也是這些習語失敗的一個主要原因。 更為詳細的介紹可以參考 Java單例模式中雙重檢查鎖的問題 。所以單例模式創(chuàng)建比較建議使用惡漢式創(chuàng)建或者靜態(tài)內(nèi)部類方式創(chuàng)建。
3.synchronized不具有繼承性
我們可以通過一個簡單的demo驗證這個問題，在一個方法中順序的輸出一系列數(shù)字，并且輸出該數(shù)字所在的線程名稱，在父類中加上synchronized關(guān)鍵字，子類重寫父類方法測試一下加上synchronized關(guān)鍵字和不加關(guān)鍵字的區(qū)別即可。
|
1
2
3
4
5
6
7
8
9
10
11
12
|
public class Parent { public synchronized void test() { for (int i = 0; i < 5; i++) { System.out.println("Parent " + Thread.currentThread().getName() + ":" + i); try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } } } } |
子類繼承父類Parent，重寫test()方法.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public class Child extends Parent { @Override public void test() { for (int i = 0; i < 5; i++) { System.out.println("Child " + Thread.currentThread().getName() + ":" + i); try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } } } } |
測試代碼如下：
|
1
2
3
4
5
6
7
8
9
10
11
|
final Child c = new Child(); new Thread() { public void run() { c.test(); }; }.start(); new Thread() { public void run() { c.test(); }; }.start(); |
輸出結(jié)果如下：
|
1
2
3
4
5
6
7
8
9
10
|
Parent Thread-0:0 Child Thread-0:0Parent Thread-0:1 Child Thread-1:0Parent Thread-0:2 Child Thread-0:1Parent Thread-0:3 Child Thread-1:1Parent Thread-0:4 Child Thread-0:2Parent Thread-1:0 Child Thread-1:2Parent Thread-1:1 Child Thread-0:3Parent Thread-1:2 Child Thread-1:3Parent Thread-1:3 Child Thread-0:4Parent Thread-1:4 Child Thread-1:4 |
通過輸出信息可以知道，父類Parent中會將單個線程中序列號輸出完成才會執(zhí)行另一個線程中代碼，但是子類Child中確是兩個線程交替輸出數(shù)字，所以synchronized不具有繼承性。
4.死鎖示例
死鎖是多線程開發(fā)中比較常見的一個問題。若有多個線程訪問多個資源時，相互之間存在競爭，就容易出現(xiàn)死鎖。下面就是一個死鎖的示例，當一個線程等待另一個線程持有的鎖時，而另一個線程也在等待該線程鎖持有的鎖，這時候兩個線程都會處于阻塞狀態(tài)，程序便出現(xiàn)死鎖。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
|
public class Thread01 extends Thread{ private Object resource01; private Object resource02; public Thread01(Object resource01, Object resource02) { this.resource01 = resource01; this.resource02 = resource02; } @Override public void run() { synchronized(resource01){ System.out.println("Thread01 locked resource01"); try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (resource02) { System.out.println("Thread01 locked resource02"); } } } } public class Thread02 extends Thread{ private Object resource01; private Object resource02; public Thread02(Object resource01, Object resource02) { this.resource01 = resource01; this.resource02 = resource02; } @Override public void run() { synchronized(resource02){ System.out.println("Thread02 locked resource02"); try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (resource01) { System.out.println("Thread02 locked resource01"); } } } } public class MainTest { public static void main(String[] args) { final Object resource01="resource01"; final Object resource02="resource02"; Thread01thread01=new Thread01(resource01, resource02); Thread02thread02=new Thread02(resource01, resource02); thread01.start(); thread02.start(); } } |
執(zhí)行上面的程序就會一直等待下去，出現(xiàn)死鎖。當線程Thread01獲得resource01的鎖后，等待500ms，然后嘗試獲取resource02的鎖，但是此時resouce02鎖已經(jīng)被Thread02持有，同樣Thread02也等待了500ms嘗試獲取resouce01鎖，但是該所已經(jīng)被Thread01持有，這樣兩個線程都在等待對方所有的資源，造成了死鎖。
三.其它
關(guān)鍵字synchronized具有鎖重入功能，當一個線程已經(jīng)持有一個對象鎖后，再次請求該對象鎖時是可以得到該對象的鎖的，這種方式是必須的，否則在一個synchronized方法內(nèi)部就沒有辦法調(diào)用該對象的另外一個synchronized方法了。鎖重入是通過為每個所關(guān)聯(lián)一個計數(shù)器和一個占有它的線程，當計數(shù)器為0時，認為鎖是未被占有的。線程請求一個未被占有的鎖時，JVM會記錄鎖的占有者，并將計數(shù)器設(shè)置為1。如果同一個線程再次請求該鎖，計數(shù)器會遞增，每次占有的線程退出同步代碼塊時計數(shù)器會遞減，直至減為0時鎖才會被釋放。
在聲明一個對象作為鎖的時候要注意字符串類型鎖對象，因為字符串有一個常量池，如果不同的線程持有的鎖是具有相同字符的字符串鎖時，兩個鎖實際上同一個鎖。
以上就是本文的全部內(nèi)容，希望本文的內(nèi)容對大家的學習或者工作能帶來一定的幫助，同時也希望多多支持服務(wù)器之家！
原文鏈接：http://www.cnblogs.com/wangyayun/p/6593446.html
