Java表示式的陷阱——多執行緒的陷阱
阿新 • • 發佈：2018-12-25
6、多執行緒的陷阱
Java語言提供了非常優秀的多執行緒支援，使得開發者能以簡單的程式碼來建立、啟動多執行緒，而且Java語言內建了多執行緒支援極好地簡化了多執行緒程式設計。雖然如此，Java多執行緒程式設計中依然存在一些容易混淆的陷阱。6、1 不要呼叫run()方法
從Java5開始，Java提供了三種方式來建立、啟動多執行緒。- 繼承Thread類建立執行緒類，重寫run()方法作為執行緒執行體。
- 實現Runnable介面建立執行緒類，重寫run()方法作為執行緒執行體。
- 實現Callable介面建立執行緒類，重寫call()方法作為執行緒執行體。
- 執行緒類繼承了Thread類，無法再繼承其他父類。
- 因為每條執行緒都是Thread子類的例項，因此可以將多條執行緒的執行流程式碼與業務資料分離。
程式執行的大致過程如下所示。public class InvokeRun extends Thread { private int i; public void run() { for ( ; i < 100 ; i ++ ) { //直接呼叫run方法時，Thread的this.getName返回的是該物件名字，而不是當前執行緒的名字 //使用Thread.currentThread().getName()總是獲取當前執行緒的名字 System.out.println(Thread.currentThread().getName() + " " + i); } } public static void main(String[] args) { for ( int i = 0 ; i < 100 ; i ++ ) { System.out.println(Thread.currentThread().getName() + " " + i); if ( i == 20 ) { //直接呼叫執行緒的run()方法，系統會把執行緒物件當成普通物件，把run方法當成普通方法 new InvokeRun().run(); new InvokeRun().run(); } } } }
- 輸出main20之後，又重新開始輸出main0.
- 從main0一直輸出到main99，再次從main0開始輸出。
- 從main0一直輸出到main99，再次從main21開始輸出，直到main99結束。
6、2 靜態的同步方法
Java提供了synchronized關鍵字用於修飾方法，使用 synchronized修飾的方法被稱為同步方法。當然，synchronized關鍵字除了修飾方法之外，還可以修飾普通程式碼塊，使用synchronized修飾的程式碼塊被稱為同步程式碼塊。 Java語法規定：任何執行緒進入同步方法、同步程式碼塊之前，必須先獲取同步方法、同步程式碼塊對應的同步監視器。對於同步程式碼塊而言，程式必須顯示地為它指定同步監視器；對於同步非靜態方法而言，該方法的同步監視器是this，即呼叫該方法的Java物件；對於靜態的同步方法而言，該方法的同步監視器不是this，而是該類本身。public class SynchronizedStatic implements Runnable {
static boolean staticFlag = true;
public static synchronized void test0() {
for ( int i = 0 ; i < 100 ; i ++ ) {
System.out.println("test0:" + Thread.currentThread().getName() + " " + i);
}
}
public void test1() {
synchronized (this) {
for ( int i = 0 ; i < 100 ; i ++ ) {
System.out.println("test1:" + Thread.currentThread().getName() + " " + i);
}
}
}
@Override
public void run() {
if (staticFlag) {
staticFlag = false;
test0();
}
else {
staticFlag = true;
test1();
}
}
public static void main(String[] args) throws Exception {
SynchronizedStatic ss = new SynchronizedStatic();
new Thread(ss).start();
Thread.sleep(10);
new Thread(ss).start();
}
} public void test1() {
synchronized (SynchronizedStatic.class) {
for ( int i = 0 ; i < 100 ; i ++ ) {
System.out.println("test1:" + Thread.currentThread().getName() + " " + i);
}
}
}6、3 靜態初始化塊啟動新執行緒執行初始化
public class StaticThreadInit {
static {
Thread t = new Thread() {
public void run() {
System.out.println("進入run方法");
System.out.println(website);
website = "www.sohu.com";
System.out.println("退出run方法");
}
};
t.start();
try {
t.join();
}
catch (Exception e) {
e.printStackTrace();
}
}
static String website = "www.baidu.com";
public static void main(String[] args) {
System.out.println(StaticThreadInit.website);
}
}上面程式定義了一個靜態的website，併為其指定了初試值，但程式也在靜態初始化塊中也為website進行賦值，且靜態初始化塊排在前面。如果只是保留這樣的程式結果，那麼程式的結果將會非常的清晰：靜態初始化先將為website賦值為www.sohu.com，然後初始化機制再將website賦值為www.baidu.com。但是程式中的靜態初始化塊是啟動一條新的執行緒來執行初始化塊操作，就導致最終只輸出“ 進入run方法”，不會繼續向下執行。 下面詳細分析該程式的執行細節。程式總是先從main方法開始執行，main方法只有一行程式碼，訪問StaticThreadInit類的website靜態field的值。當某條執行緒試圖訪問一個類的靜態field時，根據該類的狀態可能出現如下四種情況。
- 該類尚未被初始化：當前執行緒開始對其執行初始化。
- 該類正在被當前執行緒執行初始化：這是對初始化的遞迴請求。
- 該類正在被其他執行緒執行初始化：當前執行緒暫停，等待其他執行緒初始化完成。
- 這個類已經被初始化：直接得到該靜態field的值。
- 為該類的所有靜態field分配記憶體。
- 呼叫靜態初始化塊的程式碼執行初始化。
static {
Thread t = new Thread() {
public void run() {
System.out.println("進入run方法");
System.out.println(website);
website = "www.sohu.com";
System.out.println("退出run方法");
}
};
t.start();
}進入run方法
www.baidu.com
退出run方法 兩次訪問website的值都是www.baidu.com。再來分析一下執行的過程，main執行緒進入StaticThreadInit靜態初始化塊之後，同樣也是建立並啟動了新執行緒，由於此時並未呼叫新執行緒的join()方法，因此新執行緒出於就緒狀態，還未進入到執行狀態。main執行緒繼續執行初始化操作，它會將website的值初始化為www.baidu.com，至此StaticThreadInit類初始化完成。程式也就會輸出www.baidu.com。接下來新執行緒才進入執行狀態，依次執行run()方法裡的每行程式碼，此時訪問道德website的值依然是www.baidu.com，run方法()最後將website的值改為www.sohu.com，但程式已經不再訪問它了。 產生上面執行結果的原因是呼叫一條執行緒的start()方法後，該執行緒並不會立即進入執行狀態，它只是保持在就緒狀態。為了改變這種狀態，再次將StaticThreadInit類的靜態初始化塊程式碼，如下所示。
static {
Thread t = new Thread() {
public void run() {
System.out.println("進入run方法");
System.out.println(website);
website = "www.sohu.com";
System.out.println("退出run方法");
}
};
t.start();
try {
Thread.sleep(1);
}
catch (Exception e) {
e.printStackTrace();
}
}www.baidu.com
www.baidu.com
退出run方法 上面程式呼叫新執行緒的start()方法啟動新執行緒後，立即呼叫Thread.sleep(1)暫停當前執行緒，使得新執行緒立即獲得執行機會。即使讓新執行緒立即啟動，新執行緒為website指定的值依然沒有起作用。這依然和類初始化機制有關。當main執行緒進入StaticThreadInit類的靜態初始化塊後，main執行緒建立、啟動一天新執行緒，然後主執行緒呼叫Thread.sleep(1)暫停自己，是的新執行緒獲得執行機會，於是看到了執行結果的第一行輸出“進入run方法”。然後，新執行緒檢視執行System.out.println(website);來輸出website的值，但由於StaticThreadInit類還未初始化完成，因此新執行緒不得不放棄執行。執行緒排程器再次切換到main執行緒，於是main執行緒將website初始化為www.baidu.com，至此StaticThreadInit類初始化完成。 通常main執行緒不會立刻切換回來執行新執行緒，它會執行main方法裡的第一行程式碼，也就是輸出website的值，於是看到輸出結果第二行“www.baidu.com”。main執行緒執行完後，系統切換回來執行新執行緒，新執行緒訪問website時也會輸出www.baidu.com，也就是輸出結果第三行。run方法()最後將website的值改為www.sohu.com，但程式已經不再訪問它了。 實際上有一個問題：靜態初始化塊裡啟動新執行緒對靜態field賦值根本不是初始化，它只是一次普通的賦值。
public class StaticThreadInit2 {
static {
Thread t = new Thread() {
public void run() {
website = "www.sohu.com"; //報錯：The final field StaticThreadInit2.website cannot be assigned
}
};
t.start();
}
final static String website; //報錯：The blank final field website may not have been initialized
public static void main(String[] args) {
System.out.println(StaticThreadInit2.website);
}
}6、4 多執行緒執行環境
在不考慮多執行緒環境的情況下，很多程式碼都是完全正確的。但一旦將它們放在多執行緒環境下，這個類就變得非常的容易出錯，這種類被稱為執行緒不安全類。在多執行緒環境下使用執行緒不安全的類總是危險的，多執行緒環境下應該使用執行緒安全的類。public class Account {
private String accountNo;
private double balance; //賬戶餘額
public Account() {}
public Account(String accountNo , double balance) {
this.accountNo = accountNo;
this.balance = balance;
}
public double getBalance() {
return this.balance;
}
public void draw(double drawAmount) {
if ( balance >= drawAmount ) {
System.out.println(Thread.currentThread().getName() + "取錢成功！吐出鈔票：" + drawAmount);
balance -= drawAmount;
System.out.println("\t餘額為：" + balance);
}
else {
System.out.println(Thread.currentThread().getName() + "取錢失敗！餘額不足！");
}
}
public int hashCode() {
return accountNo.hashCode();
}
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (obj.getClass() == Account.class) {
Account target = (Account)obj;
return accountNo.equals(target.accountNo);
}
return false;
}
}class DrawThread extends Thread{
private Account account; //模擬賬戶
private double drawAmount; //模擬取款金額
public DrawThread(String name , Account account , double drawAmount) {
super(name);
this.account = account;
this.drawAmount = drawAmount;
}
public void run() {
account.draw(drawAmount);
}
}
public class DrawTest {
public static void main(String[] args) {
Account acc = new Account("123456" , 1000);
new DrawThread("甲", acc, 800).start();
new DrawThread("乙", acc, 800).start();
}
}餘額為：200.0
甲取錢成功！吐出鈔票：800.0
餘額為：-600.0 從結果來看這個程式出現了問題，該賬戶餘額只有1000元，但這兩條執行緒各自取走了800元，這就是有Account類執行緒不安全導致的。為了將Account類能更好地適用於多執行緒的環境，可以將Account類修改為執行緒安全的形式。執行緒安全的類具有如下特徵。
- 該類的物件可以被多個執行緒安全地訪問。
- 每個執行緒呼叫該物件的任意方法之後都將得到正確結果。
- 每個執行緒呼叫該物件的任意方法之後，該物件狀態依然保持合理狀態。
public class Account {
private String accountNo;
private double balance; //賬戶餘額
public Account() {}
public Account(String accountNo , double balance) {
this.accountNo = accountNo;
this.balance = balance;
}
public synchronized double getBalance() { //使用synchronized關鍵字修飾
return this.balance;
}
public synchronized void draw(double drawAmount) { //使用synchronized關鍵字修飾
if ( balance >= drawAmount ) {
System.out.println(Thread.currentThread().getName() + "取錢成功！吐出鈔票：" + drawAmount);
balance -= drawAmount;
System.out.println("\t餘額為：" + balance);
}
else {
System.out.println(Thread.currentThread().getName() + "取錢失敗！餘額不足！");
}
}
public int hashCode() {
return accountNo.hashCode();
}
public boolean equals(Object obj) {
if (obj == this) {
return true;
}
if (obj.getClass() == Account.class) {
Account target = (Account)obj;
return accountNo.equals(target.accountNo);
}
return false;
}
}