Java的synchronized用法及死鎖
《程式設計思想之多執行緒與多程序(1)——以作業系統的角度述說執行緒與程序》一文詳細講述了執行緒、程序的關係及在作業系統中的表現,這是多執行緒學習必須瞭解的基礎。本文將接著講一下Java執行緒同步中的一個重要的概念synchronized.
synchronized是Java中的關鍵字,是一種同步鎖。它修飾的物件有以下幾種:
1. 修飾一個程式碼塊,被修飾的程式碼塊稱為同步語句塊,其作用的範圍是大括號{}括起來的程式碼,作用的物件是呼叫這個程式碼塊的物件;
2. 修飾一個方法,被修飾的方法稱為同步方法,其作用的範圍是整個方法,作用的物件是呼叫這個方法的物件;
3. 修改一個靜態的方法,其作用的範圍是整個靜態方法,作用的物件是這個類的所有物件;
4. 修改一個類,其作用的範圍是synchronized後面括號括起來的部分,作用主的物件是這個類的所有物件。
修飾一個程式碼塊
- 一個執行緒訪問一個物件中的synchronized(this)同步程式碼塊時,其他試圖訪問該物件的執行緒將被阻塞。我們看下面一個例子:
【Demo1】:synchronized的用法
SyncThread的呼叫:/** * 同步執行緒 */ class SyncThread implements Runnable { private static int count; public SyncThread() { count = 0; } public void run() { synchronized(this) { for (int i = 0; i < 5; i++) { try { System.out.println(Thread.currentThread().getName() + ":" + (count++)); Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } } } public int getCount() { return count; } }
SyncThread syncThread = new SyncThread();
Thread thread1 = new Thread(syncThread, "SyncThread1");
Thread thread2 = new Thread(syncThread, "SyncThread2");
thread1.start();
thread2.start();
結果如下:
當兩個併發執行緒(thread1和thread2)訪問同一個物件(syncThread)中的synchronized程式碼塊時,在同一時刻只能有一個執行緒得到執行,另一個執行緒受阻塞,必須等待當前執行緒執行完這個程式碼塊以後才能執行該程式碼塊。Thread1和thread2是互斥的,因為在執行synchronized程式碼塊時會鎖定當前的物件,只有執行完該程式碼塊才能釋放該物件鎖,下一個執行緒才能執行並鎖定該物件。SyncThread1:0 SyncThread1:1 SyncThread1:2 SyncThread1:3 SyncThread1:4 SyncThread2:5 SyncThread2:6 SyncThread2:7 SyncThread2:8 SyncThread2:9*
我們再把SyncThread的呼叫稍微改一下:
Thread thread1 = new Thread(new SyncThread(), "SyncThread1");
Thread thread2 = new Thread(new SyncThread(), "SyncThread2");
thread1.start();
thread2.start();
結果如下:
SyncThread1:0
SyncThread2:1
SyncThread1:2
SyncThread2:3
SyncThread1:4
SyncThread2:5
SyncThread2:6
SyncThread1:7
SyncThread1:8
SyncThread2:9
不是說一個執行緒執行synchronized程式碼塊時其它的執行緒受阻塞嗎?為什麼上面的例子中thread1和thread2同時在執行。這是因為synchronized只鎖定物件,每個物件只有一個鎖(lock)與之相關聯,而上面的程式碼等同於下面這段程式碼:
SyncThread syncThread1 = new SyncThread();
SyncThread syncThread2 = new SyncThread();
Thread thread1 = new Thread(syncThread1, "SyncThread1");
Thread thread2 = new Thread(syncThread2, "SyncThread2");
thread1.start();
thread2.start();
這時建立了兩個SyncThread的物件syncThread1和syncThread2,執行緒thread1執行的是syncThread1物件中的synchronized程式碼(run),而執行緒thread2執行的是syncThread2物件中的synchronized程式碼(run);我們知道synchronized鎖定的是物件,這時會有兩把鎖分別鎖定syncThread1物件和syncThread2物件,而這兩把鎖是互不干擾的,不形成互斥,所以兩個執行緒可以同時執行。
2.當一個執行緒訪問物件的一個synchronized(this)同步程式碼塊時,另一個執行緒仍然可以訪問該物件中的非synchronized(this)同步程式碼塊。
【Demo2】:多個執行緒訪問synchronized和非synchronized程式碼塊
class Counter implements Runnable{
private int count;
public Counter() {
count = 0;
}
public void countAdd() {
synchronized(this) {
for (int i = 0; i < 5; i ++) {
try {
System.out.println(Thread.currentThread().getName() + ":" + (count++));
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//非synchronized程式碼塊,未對count進行讀寫操作,所以可以不用synchronized
public void printCount() {
for (int i = 0; i < 5; i ++) {
try {
System.out.println(Thread.currentThread().getName() + " count:" + count);
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void run() {
String threadName = Thread.currentThread().getName();
if (threadName.equals("A")) {
countAdd();
} else if (threadName.equals("B")) {
printCount();
}
}
}
Counter counter = new Counter();
Thread thread1 = new Thread(counter, "A");
Thread thread2 = new Thread(counter, "B");
thread1.start();
thread2.start();
結果如下:
A:0
B count:1
A:1
B count:2
A:2
B count:3
A:3
B count:4
A:4
B count:5
上面程式碼中countAdd是一個synchronized的,printCount是非synchronized的。從上面的結果中可以看出一個執行緒訪問一個物件的synchronized程式碼塊時,別的執行緒可以訪問該物件的非synchronized程式碼塊而不受阻塞。
在用synchronized修飾方法時要注意以下幾點:
1. synchronized關鍵字不能繼承。
雖然可以使用synchronized來定義方法,但synchronized並不屬於方法定義的一部分,因此,synchronized關鍵字不能被繼承。如果在父類中的某個方法使用了synchronized關鍵字,而在子類中覆蓋了這個方法,在子類中的這個方法預設情況下並不是同步的,而必須顯式地在子類的這個方法中加上synchronized關鍵字才可以。當然,還可以在子類方法中呼叫父類中相應的方法,這樣雖然子類中的方法不是同步的,但子類呼叫了父類的同步方法,因此,子類的方法也就相當於同步了。這兩種方式的例子程式碼如下:
在子類方法中加上synchronized關鍵字
class Parent {
public synchronized void method() { }
}
class Child extends Parent {
public synchronized void method() { }
}
在子類方法中呼叫父類的同步方法
class Parent {
public synchronized void method() { }
}
class Child extends Parent {
public void method() { super.method(); }
}
- 在定義介面方法時不能使用synchronized關鍵字。
- 構造方法不能使用synchronized關鍵字,但可以使用synchronized程式碼塊來進行同步。
B. 每個物件只有一個鎖(lock)與之相關聯,誰拿到這個鎖誰就可以執行它所控制的那段程式碼。
C. 實現同步是要很大的系統開銷作為代價的,甚至可能造成死鎖,所以儘量避免無謂的同步控制。
死鎖
public class TestDeadLock implements Runnable {
public int flag = 1;
//靜態物件屬於整個類
static Object o1 = new Object(), o2 = new Object();
public void run() {
System.out.println("flag=" + flag);
if(flag == 1) {
synchronized(o1) {
try {
Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
synchronized(o2) {
System.out.println("1");
}
}
}
if(flag == 0) {
synchronized(o2) {
try {
Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
synchronized(o1) {
System.out.println("0");
}
}
}
}
public static void main(String[] args) {
TestDeadLock td1 = new TestDeadLock();
TestDeadLock td2 = new TestDeadLock();
td1.flag = 1;
td2.flag = 0;
Thread t1 = new Thread(td1);
Thread t2 = new Thread(td2);
t1.start();
t2.start();
}
}
由於兩個物件都要等到對方釋放,導致死鎖。