Java 多執行緒的同步,靠的是物件鎖機制。synchronized 關鍵字之所以能做到互斥,背後正是「取得某個物件的鎖、用完再釋放」這套流程。理解這一點,比死記語法重要得多——因為許多人以為在 run() 前面加上 synchronized 就能讓執行緒乖乖排隊,實測卻完全不是那回事。
我們建立 10 個執行緒,每個執行緒印出 0 到 99 這 100 個數字,並期望輸出是「一個執行緒印完 0–99,換下一個執行緒」的順序,而不是彼此交錯。
package com.vista;
class MyThread implements java.lang.Runnable {
private int threadId;
public MyThread(int id) {
this.threadId = id;
}
@Override
public synchronized void run() {
for (int i = 0; i < 100; ++i) {
System.out.println("Thread ID: " + this.threadId + " : " + i);
}
}
}
public class ThreadDemo {
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 10; ++i) {
new Thread(new MyThread(i)).start();
Thread.sleep(1);
}
}
}
結果完全沒有同步。原因在於:實例方法上的 synchronized 鎖住的是 this,也就是執行緒物件本身。我們建了 10 個 MyThread 實例,等於有 10 把各自不同的鎖,彼此互不干涉,自然談不上互斥。
由此可得第一條結論:要實現同步,這些執行緒必須去競爭同一把共享的物件鎖。
既然要「同一把鎖」,那就先建一個 Object,把它的參照傳給每一個執行緒物件,讓各自的 lock 欄位都指向同一個物件;再在 run() 裡用 synchronized(lock) 做局部封鎖。
package com.vista;
class MyThread implements java.lang.Runnable {
private int threadId;
private Object lock;
public MyThread(int id, Object obj) {
this.threadId = id;
this.lock = obj;
}
@Override
public void run() {
synchronized (lock) {
for (int i = 0; i < 100; ++i) {
System.out.println("Thread ID: " + this.threadId + " : " + i);
}
}
}
}
public class ThreadDemo {
public static void main(String[] args) throws InterruptedException {
Object obj = new Object();
for (int i = 0; i < 10; ++i) {
new Thread(new MyThread(i, obj)).start();
Thread.sleep(1);
}
}
}
這次輸出整齊了。關鍵就在於「外部建立共享資源,再傳進執行緒裡」。
既然類別的靜態成員被所有實例共享,那麼把 lock 宣告為 static,就不必從外部傳參:
package com.vista;
class MyThread implements java.lang.Runnable {
private int threadId;
private static Object lock = new Object();
public MyThread(int id) {
this.threadId = id;
}
@Override
public void run() {
synchronized (lock) {
for (int i = 0; i < 100; ++i) {
System.out.println("Thread ID: " + this.threadId + " : " + i);
}
}
}
}
public class ThreadDemo {
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 10; ++i) {
new Thread(new MyThread(i)).start();
Thread.sleep(1);
}
}
}
回到最初的類別:實例方法上的 synchronized 鎖的是 this,而靜態方法上的 synchronized 鎖的是類別本身。靜態方法為所有實例共享,因此執行緒在進入時是互斥的,同步也就成立了:
package com.vista;
class MyThread implements java.lang.Runnable {
private int threadId;
public MyThread(int id) {
this.threadId = id;
}
@Override
public void run() {
taskHandler(this.threadId);
}
private static synchronized void taskHandler(int threadId) {
for (int i = 0; i < 100; ++i) {
System.out.println("Thread ID: " + threadId + " : " + i);
}
}
}
public class ThreadDemo {
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 10; ++i) {
new Thread(new MyThread(i)).start();
Thread.sleep(1);
}
}
}
三個成功案例本質上是同一件事:讓所有執行緒競爭同一個共享資源。差別只在鎖從哪裡來——外部傳入、靜態欄位,或直接用類別物件本身。
實務上,「外部傳入共享鎖」彈性最高:同一個類別可以有多組互不干擾的鎖,粒度可以自由控制。「靜態鎖」最省事,但粒度是整個類別,容易變成過度同步而拖慢效能。至於「synchronized 靜態方法」,適合本來就應該全域互斥的操作,但要小心它鎖的是 Class 物件,若類別被繼承、或同一個 Class 在別處也被當鎖使用,就可能出現意料之外的互斥。
最後提醒兩點。其一,synchronized 只保證同一把鎖之間的互斥, unrelated 的程式碼段各自持有不同的鎖時,完全不會互相阻擋——這正是第一段程式碼失敗的根源。其二,鎖的範圍盡量縮小、只包住真正需要保護的共享狀態,這是降低鎖競爭的通用原則。至於範例中的 System.out.println 本身就帶有同步,這裡用它只是為了方便觀察順序,實際專案中請勿以此作為同步教學的依據。