Java語言的關鍵字,當它用來修飾一個方法或者一個代碼塊的時候,能夠保證在同一時刻最多只有一個線程執行該段代碼。
1.方法聲明時使用,放在範圍操作符(public等)之後,返回類型聲明(void等)之前.這時,線程獲得的是成員鎖,即一次只能有一個線程進入該方法,其他線程要想在此時調用該方法,只能排隊等候,當前線程(就是在synchronized方法內部的線程)執行完該方法後,別的線程才能進入.
例如:
public synchronized void synMethod() { //方法體}2.對某一代碼塊使用,synchronized後跟括號,括號裡是變量,這樣,一次只有一個線程進入該代碼塊.此時,線程獲得的是成員鎖.例如:
public int synMethod(int a1){ synchronized(a1) { //一次只能有一個線程進入} } 3.synchronized後面括號裡是一對象,此時,線程獲得的是對象鎖.例如:
public class MyThread implements Runnable { public static void main(String args[]) { MyThread mt = new MyThread(); Thread t1 = new Thread(mt, "t1"); Thread t2 = new Thread(mt, "t2") ; Thread t3 = new Thread(mt, "t3"); Thread t4 = new Thread(mt, "t4"); Thread t5 = new Thread(mt, "t5"); Thread t6 = new Thread(mt, "t6 "); t1.start(); t2.start(); t3.start(); t4.start(); t5.start(); t6.start(); } public void run() { synchronized (this) { System.out.println(Thread.currentThread().getName()); } }}對於3,如果線程進入,則得到當前對象鎖,那麼別的線程在該類所有對像上的任何操作都不能進行.在對象級使用鎖通常是一種比較粗糙的方法。為什麼要將整個對像都上鎖,而不允許其他線程短暫地使用對像中其他同步方法來訪問共享資源?如果一個對象擁有多個資源,就不需要只為了讓一個線程使用其中一部分資源,就將所有線程都鎖在外面。由於每個對像都有鎖,可以如下所示使用虛擬對象來上鎖:
class FineGrainLock { MyMemberClass x, y; Object xlock = new Object(), ylock = new Object(); public void foo() { synchronized(xlock) { //access x here } //do something here - but don't use shared resources synchronized(ylock) { //access y here } } public void bar() { synchronized(this) { //access both x and y here } //do something here - but don't use shared resources } }4.synchronized後面括號裡是類,此時,線程獲得的是對象鎖.例如:
class ArrayWithLockOrder{ private static long num_locks = 0; private long lock_order; private int[] arr; public ArrayWithLockOrder(int[] a) { arr = a; synchronized(ArrayWithLockOrder.class) {//-----這裡num_locks++; // 鎖數加1。 lock_order = num_locks; // 為此對象實例設置唯一的lock_order。 } } public long lockOrder() { return lock_order; } public int[] array() { return arr; } } class SomeClass implements Runnable { public int sumArrays(ArrayWithLockOrder a1, ArrayWithLockOrder a2) { int value = 0; ArrayWithLockOrder first = a1 ; // 保留數組引用的一個ArrayWithLockOrder last = a2; // 本地副本。 int size = a1.array().length; if (size == a2.array().length) { if (a1.lockOrder() > a2.lockOrder()) // 確定並設置對象的鎖定{ //順序。 first = a2; last = a1; } synchronized(first) { // 按正確的順序鎖定對象。 synchronized(last) { int[] arr1 = a1.array(); int[] arr2 = a2.array(); for (int i=0; i<size; i++) value += arr1[i] + arr2[ i]; } } } return value; } public void run() { // } }對於4,如果線程進入,則線程在該類中所有操作不能進行,包括靜態變量和靜態方法,實際上,對於含有靜態方法和靜態變量的代碼塊的同步,我們通常用4來加鎖.
PS:synchronized 用法總結
synchronized用到不同地方對代碼產生的影響:
1. synchronized關鍵字修飾方法
假設P1、P2是同一個類的不同對象,這個類中定義了以下幾種情況的同步塊或同步方法,P1、P2就都能夠調用他們。
public synchronized void method(){ // }這也就是同步方法,那這時synchronized鎖定的是調用這個同步方法對象。也就是說,當一個對象P1在不同的線程中執行這個同步方法時,他們之間會形成互斥,達到同步的效果。同時如果該對像中有多個同步方法,則當一個線程獲執行對像中的一個synchronized方法,則該對像中其它同步方法也不允許別的線程執行。但是這個對象所屬的Class所產生的另一對象P2卻能夠任意調用這個被加了synchronized關鍵字的方法。
上邊的示例代碼等同於如下代碼:
public void method() { synchronized (this) { //.. } }此次就是一個P1對象的對象鎖,哪個拿到了P1對象鎖的線程,才能夠調用P1的同步方法,而對P2而言,P1這個鎖和他毫不相干,程式也可能在這種情形下擺脫同步機制的控制,造成數據混亂。
2.同步塊,示例代碼如下:
public void method() { synchronized (this) { //.. } }這時,鎖就是so這個對象,每個對像對應一個唯一的鎖,所以哪個線程拿到這個對象鎖誰就能夠運行他所控制的那段代碼。當有一個明確的對像作為鎖時,就能夠這樣寫程式,但當沒有明確的對像作為鎖,只是想讓一段代碼同步時,能夠創建一個特別的instance變量(他得是個對象)來充當鎖:
private byte[] lock = new byte[0]; Public void method(){ synchronized(lock) { // } }注:零長度的byte數組對象創建起來將比任何對像都經濟查看編譯後的字節碼:生成零長度的byte[]對像只需3條操作碼,而Object lock = new Object()則需要7行操作碼。
3.將synchronized作用於static 函數,示例代碼如下:
Class Foo { public synchronized static void method1() { //. } public void method2() { synchronized(Foo.class) // } }這兩個同步方法都調用這個方法的對象所屬的類的類鎖(Class,而不再是由這個Class產生的某個具體對象了)。
能夠推斷:假如一個類中定義了一個synchronized的static函數A,也定義了一個synchronized 的instance函數B,那麼這個類的同一對象Obj在多線程中分別訪問A和B兩個方法時,不會構成同步,因為他們的鎖都不相同。 A方法的鎖是Obj所屬的那個Class,而B的鎖是Obj所屬的這個對象。