圖片上傳 密碼修改為 synchronized是java中用于同步的關鍵字，一般我們通過Synchronized鎖住一個對象，來進行線程同步。我們需要了解在程序執行過程中，synchronized鎖住的到底是哪個對象，否則我們在多線程的程序就有可能出現問題。
看下面的代碼，我們定義了一個靜態變量n,在run方法中，我們使n增加10，然后在main方法中，我們開辟了100個線程，來執行n增加的操作，如果線程沒有并發執行，那么n最后的值應該為1000，顯然下面的程序執行完結果不是1000，因為我們沒有進行線程同步。
|
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
|
import java.util.concurrent.TimeUnit; public class SynchronizedTest1 extends Thread { public static int n = 0; public void run() { try { //使n自加10次 for (int i = 0; i < 10; i++) { n = n + 1; TimeUnit.MILLISECONDS.sleep(10); } } catch (InterruptedException e) { e.printStackTrace(); } } public static void main(String[] args) throws InterruptedException { Thread[] threads = new Thread[100]; for (int i = 0; i < threads.length; i++) { threads[i] = new SynchronizedTest1(); threads[i].start(); } //使所有其他線程執行完，再繼續執行main線程,這樣得出的n是最終的結果 for (Thread thread : threads) { thread.join(); } System.out.println(n); } } |
為了實現同步，我們修改上面的代碼，增加一個increase方法，如下。但是當我們執行下面的代碼時，會發現n仍然不是1000.
|
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
|
import java.util.concurrent.TimeUnit; public class SynchronizedTest2 extends Thread { public static int n = 0; public synchronized void increase() { n++; } public void run() { try { //使n自加10次 for (int i = 0; i < 10; i++) { increase(); TimeUnit.MILLISECONDS.sleep(10); } } catch (InterruptedException e) { e.printStackTrace(); } } public static void main(String[] args) throws InterruptedException { Thread[] threads = new Thread[100]; for (int i = 0; i < threads.length; i++) { threads[i] = new SynchronizedTest2(); threads[i].start(); } //使所有其他線程執行完，再繼續執行main線程,這樣得出的n是最終的結果 for (Thread thread : threads) { thread.join(); } System.out.println(n); } } |
其實原因很簡單，上面的多個線程在執行時根本就沒有競爭同一個對象鎖。當我們執行用synchronized修飾的非靜態方法時，線程會首先獲得調用這個方法的對象的鎖，然后才能繼續執行代碼。那么調用這個方法的到底是哪個對象，是this對象。在上面的例子中，thread[i]所代表的線程獲取的鎖對象是thread[i]對象，也就是該線程對象本身。因此上面所開辟的100個線程只要獲得自身對象就可以執行，這樣就使同步失去了作用。
我們再次修改代碼：即將increase方法改為i靜態的，此時程序執行完后n的值為1000。
|
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
|
import java.util.concurrent.TimeUnit; public class SynchronizedTest3 extends Thread { public static int n = 0; public synchronized static void increase() { n++; } public void run() { try { //使n自加10次 for (int i = 0; i < 10; i++) { increase(); TimeUnit.MILLISECONDS.sleep(10); } } catch (InterruptedException e) { e.printStackTrace(); } } public static void main(String[] args) throws InterruptedException { Thread[] threads = new Thread[100]; for (int i = 0; i < threads.length; i++) { threads[i] = new SynchronizedTest3(); threads[i].start(); } //使所有其他線程執行完，再繼續執行main線程,這樣得出的n是最終的結果 for (Thread thread : threads) { thread.join(); } System.out.println(n); } } |
當synchronized 修飾static方法，它鎖住的是該類的Class對象，而不是某一個具體對象。在上面的例子中，它鎖住的就是SynchronizedTest3.class對象。在程序執行過程中，類的Class對象只有一份，所以上面線程競爭的是同一個對象鎖。
下面是對synchronized鎖住對象的總結：
（1）對于同步方法，鎖當前對象（this）
（2）對于靜態同步方法，鎖當前類的Class對象
（3）對于同步代碼塊，鎖住的是synchronized括號中的對象
總結
以上就是本文關于解析Java編程之Synchronized鎖住的對象的全部內容，希望對大家有所幫助。有什么問題可以直接留言，小編會及時回復大家的。希望大家能夠喜歡。
原文鏈接：http://blog.csdn.net/zhangjk1993/article/details/23948429
