synchronized關鍵字是java並發程式設計中常用的同步鎖，用來鎖住方法或程式碼區塊，鎖定程式碼區塊時可以是synchronized(this){}、synchronized(Object){}、synchronized(類別class) {}。
當鎖定的內容執行完或執行過程中拋出異常，才會自動釋放鎖定。
如果想要手動釋放鎖，需要呼叫鎖定的物件的wait()方法釋放掉鎖定並且置於等待狀態，切換到其他執行緒運行，而notify()方法只是喚醒一個呼叫了該對象wait()方法的其他線程，但不會釋放鎖，選擇順序也不由程式碼控制，由虛擬機器實作。
因此，物件的wait()、notify()、notifyAll()方法只能是配合synchronized關鍵字使用的，來完成執行緒間的調度。
其中鎖定方法等同於synchronized(this){方法的所有程式碼作為程式碼區塊}，如下：
public synchronized void test() {
...
}等同於
public void test() {
synchronized (this) {
...
}
}上面的範例鎖住的是該類別的對象，如果鎖住的是個靜態的方法，我們知道靜態方法是屬於類別的而不屬於對象的，所以，synchronized修飾的靜態方法鎖定的是這個類別的所有對象，即就算是兩個實例對象，只要他們都是這個類的，那都會鎖住。
public synchronized static void test() {
...
}等同於
public static void test() {
synchronized (所在类.class) {
...
}
}無論是鎖定方法還是鎖定程式碼區塊，無論鎖定程式碼區塊時的參考物件是什麼，只要記住一個原則就一目了然了，那就是當參考對象相同時，同步鎖才起作用，否則鎖不會互斥，可以並發執行。
synchronized(this)表示當前類別的物件實例相同時鎖起作用，synchronized(Object)表示該Object物件相同時鎖起作用，synchronized(類別class)表示當都是該class類別時鎖起作用。
舉一個簡單的例子：
public class TestController {
public class Task implements Runnable{
private String str;
Task(String str){
this.str=str;
}
@Override
public void run() {
synchronized (str) {
try {
Thread.sleep(3000l);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(str);
}
}
}
public static void main(String[] args) throws InterruptedException {
TestController testController = new TestController();
Thread thread1 = new Thread(testController.new Task("1"));
Thread thread2 = new Thread(testController.new Task("1"));
thread1.start();
thread2.start();
}
}上述程式碼，參考物件str都是"1"，在java中，String字串如果透過this.str="1"這樣的方式賦值就等於str=String.valueOf("1")，如果字串"1"之前已經初始化過，那就會直接拿之前的，所以是同一個物件。根據上面介紹的原則，那鎖就會起作用，所以結果是3秒之後輸出1，再過3秒再輸出1。
如果把thread2改成
Thread thread2 = new Thread(testController.new Task("2"));這時參考對像一個是"1"，另一個是"2"，不是同一個對象，所以鎖不會互斥，就不會起作用，所以結果是3秒後幾乎同時輸出1和2。
以上都是多個執行緒同時呼叫同一個方法，如果呼叫不同的方法呢？
public class Test{
public synchronized void m1(){
System.out.println("m1 running...");
try {
Thread.sleep(3000l);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("m1 end");
}
public synchronized void m2(){
System.out.println("m2 running...");
System.out.println("m2 end");
}
public static void main(String[] args) {
Test test = new Test();
new Thread(new Runnable() {
@Override
public void run() {
test.m1();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
test.m2();
}
}).start();
}
}上面程式碼的輸出結果是：
m1 running... //过3秒 m1 end m2 running... m2 end
上面就說過synchronized修飾在方法上等同於synchronized(this){方法的所有程式碼作為程式碼區塊}，而this就代表是對象，也就是說，第一個Thread得到的是test物件的鎖，因為物件都是同一個test，所以第二個Thread無法取得到鎖，而被阻塞。
把上面的範例改造成如下：
private String str = "1";
public void m1(){
synchronized(str){
System.out.println("m1 running...");
try {
Thread.sleep(3000l);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("m1 end");
}
}
public void m2(){
synchronized(str){
System.out.println("m2 running...");
System.out.println("m2 end");
}
}第一個Thread呼叫m1()時取得到的是物件str的鎖，第二個Thread呼叫m2()時也需要取得對象str的鎖，而且因為是同一個Test對象，所以兩個str也是同一個對象，所以第二個Thread會因為取得不到鎖而被阻塞，輸出結果和之前的例子一樣。
如果再把上面的例子改造成如下：
public class M1 {
public void m(String str){
synchronized (str) {
System.out.println("m1 runing");
try {
Thread.sleep(3000l);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("m1 end");
}
}
}
public class M2 {
public void m(String str){
synchronized (str) {
System.out.println("m2 runing");
System.out.println("m2 end");
}
}
}
public class Test {
public static void main(String[] args) {
String str = "1";
new Thread(new Runnable() {
@Override
public void run() {
new M1().m(str);
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
new M2().m(str);
}
}).start();
}
}這次呼叫的方法在兩個類別裡面，但是結果和之前的兩個例子是一樣的，因為鎖住的都是傳進來的str對象，同一個對像只有一把鎖，第一個Thread拿了，第二個Thread就只能等待。
總結：
A. 無論synchronized關鍵字加在方法上還是物件上，如果它作用的物件是非靜態的，則它取得的鎖定是對象；如果synchronized作用的物件是一個靜態方法或一個類，則它所取得的鎖是對類，該類所有的物件同一把鎖。
B. 每個物件只有一個鎖定（lock）與之相關聯，誰拿到這個鎖誰就可以執行它所控制的那段程式碼。
C. 實現同步是要很大的系統開銷作為代價的，甚至可能造成死鎖，所以盡量避免無謂的同步控制
以上是synchronized關鍵字的使用的詳細內容。更多資訊請關注PHP中文網其他相關文章！
