在Java中，synchronized關鍵字是用來控制執行緒同步的，就是在多執行緒的環境下，控制synchronized程式碼段不被多個執行緒同時執行。 synchronized既可以加在一段程式碼上，也可以加在方法上。
關鍵是，不要認為給方法或程式碼段加上synchronized就萬事大吉，看下面一段程式碼：
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方法也相當於全域鎖，相當於鎖住了程式碼段。
