一、同步問題提出

線程的同步是為了防止多個線程訪問一個數據對象時，對數據造成的破壞。

例如：兩個線程ThreadA、ThreadB都操作同一個對象Foo對象，并修改Foo對象上的數據。

publicclass?Foo {?privateint?x = 100;?publicint?getX() {?return?x;?????}?publicint?fix(int?y) {?????????x = x - y;?return?x;?????}?}

publicclass?MyRunnable?implements?Runnable {?private?Foo foo =?new?Foo();?publicstaticvoid?main(String[] args) {?????????MyRunnable r =?new?MyRunnable();?????????Thread ta =?new?Thread(r,?"Thread-A");?????????Thread tb =?new?Thread(r,?"Thread-B");?????????ta.start();?????????tb.start();?????}?publicvoid?run() {?for?(int?i = 0; i < 3; i++) {?this.fix(30);?try?{?????????????????Thread.sleep(1);?????????????}?catch?(InterruptedException e) {?????????????????e.printStackTrace();?????????????}?????????????System.out.println(Thread.currentThread().getName() +?" : 當前foo對象的x值= "?+ foo.getX());?????????}?????}?publicint?fix(int?y) {?return?foo.fix(y);?????}?}

運行結果：

Thread-A : 當前foo對象的x值= 40?Thread-B : 當前foo對象的x值= 40?Thread-B : 當前foo對象的x值= -20?Thread-A : 當前foo對象的x值= -50?Thread-A : 當前foo對象的x值= -80?Thread-B : 當前foo對象的x值= -80?Process finished with exit code 0

從結果發現，這樣的輸出值明顯是不合理的。原因是兩個線程不加控制的訪問Foo對象并修改其數據所致。

如果要保持結果的合理性，只需要達到一個目的，就是將對Foo的訪問加以限制，每次只能有一個線程在訪問。這樣就能保證Foo對象中數據的合理性了。

在具體的Java代碼中需要完成一下兩個操作：

把競爭訪問的資源類Foo變量x標識為private；

同步哪些修改變量的代碼，使用synchronized關鍵字同步方法或代碼。

二、同步和鎖定

1、鎖的原理

Java中每個對象都有一個內置鎖

當程序運行到非靜態的synchronized同步方法上時，自動獲得與正在執行代碼類的當前實例（this實例）有關的鎖。獲得一個對象的鎖也稱為獲取鎖、鎖定對象、在對象上鎖定或在對象上同步。

當程序運行到synchronized同步方法或代碼塊時才該對象鎖才起作用。

一個對象只有一個鎖。所以，如果一個線程獲得該鎖，就沒有其他線程可以獲得鎖，直到第一個線程釋放（或返回）鎖。這也意味著任何其他線程都不能進入該對象上的synchronized方法或代碼塊，直到該鎖被釋放。

釋放鎖是指持鎖線程退出了synchronized同步方法或代碼塊。

關于鎖和同步，有一下幾個要點：

1）、只能同步方法，而不能同步變量和類；

2）、每個對象只有一個鎖；當提到同步時，應該清楚在什么上同步？也就是說，在哪個對象上同步？

3）、不必同步類中所有的方法，類可以同時擁有同步和非同步方法。

4）、如果兩個線程要執行一個類中的synchronized方法，并且兩個線程使用相同的實例來調用方法，那么一次只能有一個線程能夠執行方法，另一個
需要等待，直到鎖被釋放。也就是說：如果一個線程在對象上獲得一個鎖，就沒有任何其他線程可以進入（該對象的）類中的任何一個同步方法。

5）、如果線程擁有同步和非同步方法，則非同步方法可以被多個線程自由訪問而不受鎖的限制。

6）、線程睡眠時，它所持的任何鎖都不會釋放。

7）、線程可以獲得多個鎖。比如，在一個對象的同步方法里面調用另外一個對象的同步方法，則獲取了兩個對象的同步鎖。

8）、同步損害并發性，應該盡可能縮小同步范圍。同步不但可以同步整個方法，還可以同步方法中一部分代碼塊。

9）、在使用同步代碼塊時候，應該指定在哪個對象上同步，也就是說要獲取哪個對象的鎖。例如：

??? public int fix(int y) {??????? synchronized (this) {??????????? x = x - y;??????? }??????? return x;??? }

當然，同步方法也可以改寫為非同步方法，但功能完全一樣的，例如：

??? public synchronized int getX() {??????? return x++;??? }

與

??? public int getX() {??????? synchronized (this) {??????????? return x;??????? }??? }

效果是完全一樣的。

三、靜態方法同步

要同步靜態方法，需要一個用于整個類對象的鎖，這個對象是就是這個類（XXX.class)。

例如：

public static synchronized int setName(String name){

????? Xxx.name = name;

}

等價于public static int setName(String name){????? synchronized(Xxx.class){??????????? Xxx.name = name;????? }}

?

四、如果線程不能不能獲得鎖會怎么樣

如果線程試圖進入同步方法，而其鎖已經被占用，則線程在該對象上被阻塞。實質上，線程進入該對象的的一種池中，必須在哪里等待，直到其鎖被釋放，該線程再次變為可運行或運行為止。

當考慮阻塞時，一定要注意哪個對象正被用于鎖定：

1、調用同一個對象中非靜態同步方法的線程將彼此阻塞。如果是不同對象，則每個線程有自己的對象的鎖，線程間彼此互不干預。

2、調用同一個類中的靜態同步方法的線程將彼此阻塞，它們都是鎖定在相同的Class對象上。

3、靜態同步方法和非靜態同步方法將永遠不會彼此阻塞，因為靜態方法鎖定在Class對象上，非靜態方法鎖定在該類的對象上。

4、對于同步代碼塊，要看清楚什么對象已經用于鎖定（synchronized后面括號的內容）。在同一個對象上進行同步的線程將彼此阻塞，在不同對象上鎖定的線程將永遠不會彼此阻塞。

五、何時需要同步

在多個線程同時訪問互斥（可交換）數據時，應該同步以保護數據，確保兩個線程不會同時修改更改它。

對于非靜態字段中可更改的數據，通常使用非靜態方法訪問。

對于靜態字段中可更改的數據，通常使用靜態方法訪問。

如果需要在非靜態方法中使用靜態字段，或者在靜態字段中調用非靜態方法，問題將變得非常復雜。已經超出SJCP考試范圍了。

六、線程安全類

當一個類已經很好的同步以保護它的數據時，這個類就稱為“線程安全的”。

即使是線程安全類，也應該特別小心，因為操作的線程是間仍然不一定安全。

舉個形象的例子，比如一個集合是線程安全的，有兩個線程在操作同一個集合對象，當第一個線程查詢集合非空后，刪除集合中所有元素的時候。第二個線程也來執
行與第一個線程相同的操作，也許在第一個線程查詢后，第二個線程也查詢出集合非空，但是當第一個執行清除后，第二個再執行刪除顯然是不對的，因為此時集合
已經為空了。

看個代碼：

publicclass?NameList {?private?List nameList = Collections.synchronizedList(new?LinkedList());?publicvoid?add(String name) {?????????nameList.add(name);?????}?public?String removeFirst() {?if?(nameList.size() > 0) {?return?(String) nameList.remove(0);?????????}?else?{?returnnull;?????????}?????}?}

publicclass?Test {?publicstaticvoid?main(String[] args) {?final?NameList nl =?new?NameList();?????????nl.add("aaa");?class?NameDropper?extends?Thread{?publicvoid?run(){?????????????????String name = nl.removeFirst();?????????????????System.out.println(name);?????????????}?????????}?????????Thread t1 =?new?NameDropper();?????????Thread t2 =?new?NameDropper();?????????t1.start();?????????t2.start();?????}?}

雖然集合對象

??? private List nameList = Collections.synchronizedList(new LinkedList());是同步的，但是程序還不是線程安全的。

出現這種事件的原因是，上例中一個線程操作列表過程中無法阻止另外一個線程對列表的其他操作。

解決上面問題的辦法是，在操作集合對象的NameList上面做一個同步。改寫后的代碼如下：

publicclass?NameList {?private?List nameList = Collections.synchronizedList(new?LinkedList());?publicsynchronizedvoid?add(String name) {?????????nameList.add(name);?????}?publicsynchronized?String removeFirst() {?if?(nameList.size() > 0) {?return?(String) nameList.remove(0);?????????}?else?{?returnnull;?????????}?????}?}

這樣，當一個線程訪問其中一個同步方法時，其他線程只有等待。

七、線程死鎖

死鎖對Java程序來說，是很復雜的，也很難發現問題。當兩個線程被阻塞，每個線程在等待另一個線程時就發生死鎖。

還是看一個比較直觀的死鎖例子：

publicclass?DeadlockRisk {?privatestaticclass?Resource {?publicint?value;?????}?private?Resource resourceA =?new?Resource();?private?Resource resourceB =?new?Resource();?publicint?read() {?synchronized?(resourceA) {?synchronized?(resourceB) {?return?resourceB.value + resourceA.value;?????????????}?????????}?????}?publicvoid?write(int?a,?int?b) {?synchronized?(resourceB) {?synchronized?(resourceA) {?????????????????resourceA.value = a;?????????????????resourceB.value = b;?????????????}?????????}?????}?}

假設read()方法由一個線程啟動，write()方法由另外一個線程啟動。讀線程將擁有resourceA鎖，寫線程將擁有resourceB鎖，兩者都堅持等待的話就出現死鎖。

實際上，上面這個例子發生死鎖的概率很小。因為在代碼內的某個點，CPU必須從讀線程切換到寫線程，所以，死鎖基本上不能發生。

但是，無論代碼中發生死鎖的概率有多小，一旦發生死鎖，程序就死掉。有一些設計方法能幫助避免死鎖，包括始終按照預定義的順序獲取鎖這一策略。已經超出SCJP的考試范圍。

八、線程同步小結

1、線程同步的目的是為了保護多個線程反問一個資源時對資源的破壞。

2、線程同步方法是通過鎖來實現，每個對象都有切僅有一個鎖，這個鎖與一個特定的對象關聯，線程一旦獲取了對象鎖，其他訪問該對象的線程就無法再訪問該對象的其他同步方法。

3、對于靜態同步方法，鎖是針對這個類的，鎖對象是該類的Class對象。靜態和非靜態方法的鎖互不干預。一個線程獲得鎖，當在一個同步方法中訪問另外對象上的同步方法時，會獲取這兩個對象鎖。

4、對于同步，要時刻清醒在哪個對象上同步，這是關鍵。

5、編寫線程安全的類，需要時刻注意對多個線程競爭訪問資源的邏輯和安全做出正確的判斷，對“原子”操作做出分析，并保證原子操作期間別的線程無法訪問競爭資源。

6、當多個線程等待一個對象鎖時，沒有獲取到鎖的線程將發生阻塞。

7、死鎖是線程間相互等待鎖鎖造成的，在實際中發生的概率非常的小。真讓你寫個死鎖程序，不一定好使，呵呵。但是，一旦程序發生死鎖，程序將死掉。

?

java多線程下的鎖的概念

鎖和synchronized關鍵字
?????為了同步多線程，Java語言使用監視器(monitors)，一種高級的機制來限定某一 時刻只有一個線程執行一段受監視器保護的代碼。監視器的行為是通過鎖來實現的，每一個對象都有一個鎖。
??? 每個線程都有一個工作內存，在里面存放從所有線程共享的主內存里拷貝來的變量。為了訪問一個共享的變量，一個線程通常先要獲得一個鎖并刷新它的工作內存，這將共享的值從主內存被拷貝到工作內存。當線程解鎖時將會把工作內存里的值寫回主內存。
&n bsp;?? 一個線程能多次獲得對象的鎖。也就是說，一個synchronized方法調用了另一個synchronized方法，而后者又調用了另一synchronized方法，諸如此類。JVM會跟蹤對象被上鎖的次數。如果對象沒有被鎖住，那么它的計數器應該 為零。當線程第一次獲得對象的鎖時，計數器為一。線程每獲一次對象的鎖，計數器就加一。當然，只有第一次獲得對象鎖的線程才能多次獲得鎖。線程每退出一個synchronized方法，計數器就減一。等減到零了，對象也就解鎖了，這時其它線程就可以使用這 個對象了。
??? 此外每個類還有一個鎖(它屬于類的Class對象)，這樣當類的synchronized static方法讀取static數據的時候，就不會相互干擾了。
??? 線程之間不直接交互，它們只通過主內存進行交流。

從J2SE 1.5開始，Java有了Lock接口，將使鎖的概念更清晰，使線程同步的控制更容易。使用synchronized，你無法控制鎖的釋放，而使用Lock接口，你將可以lock()，也可以隨你需要進行unlock()。

轉載于:https://www.cnblogs.com/qqzy168/p/3921341.html

總結

以上是生活随笔為你收集整理的java多线程之线程的同步与锁定（转）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。