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所屬的這個對象。