下面這篇部落格我看講的還算是挺細的，能夠結合具體例項來說明，部落格地址為：http://www.cnblogs.com/QQParadise/articles/5059824.html

  在Java中，synchronized關鍵字是用來控制執行緒同步的，就是在多執行緒的環境下，控制synchronized程式碼段不被多個執行緒同時執行。synchronized既可以加在一段程式碼上，也可以加在方法上。

  關鍵是，不要認為給方法或者程式碼段加上synchronized就萬事大吉，看下面一段程式碼：

class Sync {
 
	public synchronized void test() {
		System.out.println("test開始..");
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("test結束..");
	}
}
 
class MyThread extends Thread {
 
	public void run() {
		Sync sync = new Sync();
		sync.test();
	}
}
 
public class Main {
 
	public static void main(String[] args) {
		for (int i = 0; i < 3; i++) {
			Thread thread = new MyThread();
			thread.start();
		}
	}
}
 

執行結果： test開始.. test開始.. test開始.. test結束.. test結束.. test結束..

可以看出來，上面的程式起了三個執行緒，同時執行Sync類中的test()方法，雖然test()方法加上了synchronized，但是還是同時執行起來，貌似synchronized沒起作用。 

將test()方法上的synchronized去掉，在方法內部加上synchronized(this)：

public void test() {
	synchronized(this){
		System.out.println("test開始..");
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("test結束..");
	}
}
 

執行結果： test開始.. test開始.. test開始.. test結束.. test結束.. test結束..

一切還是這麼平靜，沒有看到synchronized起到作用。 

  實際上，synchronized(this)以及非static的synchronized方法（至於static synchronized方法請往下看），只能防止多個執行緒同時執行同一個物件的同步程式碼段。

  回到本文的題目上：synchronized鎖住的是程式碼還是物件。答案是：synchronized鎖住的是括號裡的物件，而不是程式碼。對於非static的synchronized方法，鎖的就是物件本身也就是this。

  當synchronized鎖住一個物件後，別的執行緒如果也想拿到這個物件的鎖，就必須等待這個執行緒執行完成釋放鎖，才能再次給物件加鎖，這樣才達到執行緒同步的目的。即使兩個不同的程式碼段，都要鎖同一個物件，那麼這兩個程式碼段也不能在多執行緒環境下同時執行。

  所以我們在用synchronized關鍵字的時候，能縮小程式碼段的範圍就儘量縮小，能在程式碼段上加同步就不要再整個方法上加同步。這叫減小鎖的粒度，使程式碼更大程度的併發。原因是基於以上的思想，鎖的程式碼段太長了，別的執行緒是不是要等很久，等的花兒都謝了。當然這段是題外話，與本文核心思想並無太大關聯。

  再看上面的程式碼，每個執行緒中都new了一個Sync類的物件，也就是產生了三個Sync物件，由於不是同一個物件，所以可以多執行緒同時執行synchronized方法或程式碼段。

  為了驗證上述的觀點，修改一下程式碼，讓三個執行緒使用同一個Sync的物件。

class MyThread extends Thread {
 
	private Sync sync;
 
	public MyThread(Sync sync) {
		this.sync = sync;
	}
 
	public void run() {
		sync.test();
	}
}
 
public class Main {
 
	public static void main(String[] args) {
		Sync sync = new Sync();
		for (int i = 0; i < 3; i++) {
			Thread thread = new MyThread(sync);
			thread.start();
		}
	}
}

執行結果： test開始.. test結束.. test開始.. test結束.. test開始.. test結束..

  可以看到，此時的synchronized就起了作用。 

  那麼，如果真的想鎖住這段程式碼，要怎麼做？也就是，如果還是最開始的那段程式碼，每個執行緒new一個Sync物件，怎麼才能讓test方法不會被多執行緒執行。 

  解決也很簡單，只要鎖住同一個物件不就行了。例如，synchronized後的括號中鎖同一個固定物件，這樣就行了。這樣是沒問題，但是，比較多的做法是讓synchronized鎖這個類對應的Class物件。

class Sync {
 
	public void test() {
		synchronized (Sync.class) {
			System.out.println("test開始..");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("test結束..");
		}
	}
}
 
class MyThread extends Thread {
 
	public void run() {
		Sync sync = new Sync();
		sync.test();
	}
}
 
public class Main {
 
	public static void main(String[] args) {
		for (int i = 0; i < 3; i++) {
			Thread thread = new MyThread();
			thread.start();
		}
	}
}

執行結果： test開始.. test結束.. test開始.. test結束.. test開始.. test結束..

  上面程式碼用synchronized(Sync.class)實現了全域性鎖的效果。

  static synchronized方法，static方法可以直接類名加方法名呼叫，方法中無法使用this，所以它鎖的不是this，而是類的Class物件，所以，static synchronized方法也相當於全域性鎖，相當於鎖住了程式碼段。