編寫高效的線程安全類 
（加入日期:2001-5-6 點擊數:852）
【對此文發表評論】 【編程愛好者論壇】 【保存文章至硬盤】 【打印文章】 
 
在語言級支持鎖定對象和線程間發信使編寫線程安全類變得簡單。本文使用簡單的編程示例來說明開發高效的線程安全類是多么有效而直觀。

Java 編程語言為編寫多線程應用程序提供強大的語言支持。但是，編寫有用的、沒有錯誤的多線程程序仍然比較困難。本文試圖概述幾種方法，程序員可用這幾種方法來創建高效的線程安全類。

并發性 
只有當要解決的問題需要一定程度的并發性時，程序員才會從多線程應用程序中受益。例如，如果打印隊列應用程序僅支持一臺打印機和一臺客戶機，則不應該將它編寫為多線程的。一般說來，包含并發性的編碼問題通常都包含一些可以并發執行的操作，同時也包含一些不可并發執行的操作。例如，為多個客戶機和一個打印機提供服務的打印隊列可以支持對打印的并發請求，但向打印機的輸出必須是串行形式的。多線程實現還可以改善交互式應用程序的響應時間。

Synchronized 關鍵字 
雖然多線程應用程序中的大多數操作都可以并行進行，但也有某些操作（如更新全局標志或處理共享文件）不能并行進行。在這些情況下，必須獲得一個鎖來防止其他線程在執行此操作的線程完成之前訪問同一個方法。在 Java 程序中，這個鎖是通過 synchronized 關鍵字提供的。清單 1 說明了它的用法。

清單 1. 使用 synchronized 關鍵字來獲取鎖 public class MaxScore {
int max;
public MaxScore() {
max = 0;
}

public synchronized void currentScore(int s) {
if(s> max) {
max = s;
}
}

public int max() {
return max;
}
}



這里，兩個線程不能同時調用 currentScore() 方法；當一個線程工作時，另一個線程必須阻塞。但是，可以有任意數量的線程同時通過 max() 方法訪問最大值，因為 max() 不是同步方法，因此它與鎖定無關。

試考慮在 MaxScore 類中添加另一個方法的影響，該方法的實現如清單 2 所示。


清單 2. 添加另一個方法  public synchronized void reset() {
max = 0;
}




這個方法（當被訪問時）不僅將阻塞 reset() 方法的其他調用，而且也將阻塞 MaxScore 類的同一個實例中的 currentScore() 方法，因為這兩個方法都訪問同一個鎖。如果兩個方法必須不彼此阻塞，則程序員必須在更低的級別使用同步。清單 3 是另一種情況，其中兩個同步的方法可能需要彼此獨立。

清單 3. 兩個獨立的同步方法 import java.util.*;

public class Jury {
Vector members;
Vector alternates;

public Jury() {
members = new Vector(12, 1);
alternates = new Vector(12, 1);
}

public synchronized void addMember(String name) {
members.add(name);
}

public synchronized void addAlt(String name) {
alternates.add(name);
}

public synchronized Vector all() {
Vector retval = new Vector(members);
retval.addAll(alternates);
return retval;
}
}




此處，兩個不同的線程可以將 members 和 alternates 添加到 Jury 對象中。請記住，synchronized 關鍵字既可用于方法，更一般地，也可用于任何代碼塊。清單 4 中的兩段代碼是等效的。

清單 4. 等效的代碼 synchronized void f() {              void f() {      
// 執行某些操作                                              synchronized(this) {
}                                                    // 執行某些操作

                                            }
                                     }  




所以，為了確保 addMember() 和 addAlt() 方法不彼此阻塞，可按清單 5 所示重寫 Jury 類。

清單 5. 重寫后的 Jury 類 import java.util.*;

public class Jury {
Vector members;
Vector alternates;

public Jury() {
members = new Vector(12, 1);
alternates = new Vector(12, 1);
}

public void addMember(String name) {
synchronized(members) {
members.add(name);
}
}

public void addAlt(String name) {
synchronized(alternates) {
alternates.add(name);
}
}

public Vector all() {
Vector retval;
synchronized(members) {
retval = new Vector(members);
}

synchronized(alternates) {
retval.addAll(alternates);
}

return retval;
}
}




請注意，我們還必須修改 all() 方法，因為對 Jury 對象同步已沒有意義。在改寫后的版本中，addMember()、addAlt() 和 all() 方法只訪問與 members 和 alternates 對象相關的鎖，因此鎖定 Jury 對象毫無用處。另請注意，all() 方法本來可以寫為清單 6 所示的形式。

清單 6. 將 members 和 alternates 用作同步的對象  public Vector all() {
synchronized(members) {
synchronized(alternates) {
Vector retval;
retval = new Vector(members);
retval.addAll(alternates);
}
}
return retval;
}




但是，因為我們早在需要之前就獲得 members 和 alternates 的鎖，所以這效率不高。清單 5 中的改寫形式是一個較好的示例，因為它只在最短的時間內持有鎖，并且每次只獲得一個鎖。這樣就完全避免了當以后增加代碼時可能產生的潛在死鎖問題。

同步方法的分解 
正如在前面看到的那樣，同步方法獲取對象的一個鎖。如果該方法由不同的線程頻繁調用，則此方法將成為瓶頸，因為它會對并行性造成限制，從而會對效率造成限制。這樣，作為一個一般的原則，應該盡可能地少用同步方法。盡管有這個原則，但有時一個方法可能需要完成需要鎖定一個對象幾項任務，同時還要完成相當耗時的其他任務。在這些情況下，可使用一個動態的“鎖定-釋放-鎖定-釋放”方法。例如，清單 7 和清單 8 顯示了可按這種方式變換的代碼。

清單 7. 最初的低效率代碼 public synchonized void doWork() {
         unsafe1();
write_file();
unsafe2();
}



清單 8. 重寫后效率較高的代碼 public void doWork() {
synchonized(this) {
                 unsafe1();
}
write_file();
synchonized(this) {
unsafe2();
}
}



清單 7 和清單 8 假定第一個和第三個方法需要對象被鎖定，而更耗時的 write_file() 方法不需要對象被鎖定。如您所見，重寫此方法以后，對此對象的鎖在第一個方法完成以后被釋放，然后在第三個方法需要時重新獲得。這樣，當 write_file() 方法執行時，等待此對象的鎖的任何其他方法仍然可以運行。將同步方法分解為這種混合代碼可以明顯改善性能。但是，您需要注意不要在這種代碼中引入邏輯錯誤。

嵌套類 
內部類在 Java 程序中實現了一個令人關注的概念，它允許將整個類嵌套在另一個類中。嵌套類作為包含它的類的一個成員變量。如果定期被調用的的一個特定方法需要一個類，就可以構造一個嵌套類，此嵌套類的唯一任務就是定期調用所需的方法。這消除了對程序的其他部分的相依性，并使代碼進一步模塊化。清單 9，一個圖形時鐘的基礎，使用了內部類。

清單 9. 圖形時鐘示例 public class Clock {
protected class Refresher extends Thread {
int refreshTime;
public Refresher(int x) {
super("Refresher");
refreshTime = x;
}

public void run() {
while(true) {
try {
sleep(refreshTime);
}
catch(Exception e) {}
repaint();
}
}
}

public Clock() {
Refresher r = new Refresher(1000);
r.start();
}

private void repaint() {
// 獲取時間的系統調用
// 重繪時鐘指針
}
}




清單 9 中的代碼示例不靠任何其他代碼來調用 repaint() 方法。這樣，將一個時鐘并入一個較大的用戶界面就相當簡單。

事件驅動處理 
當應用程序需要對事件或條件（內部的和外部的）作出反映時，有兩種方法或用來設計系統。在第一種方法（稱為輪詢）中，系統定期確定這一狀態并據此作出反映。這種方法（雖然簡單）也效率不高，因為您始終無法預知何時需要調用它。

第二種方法（稱為事件驅動處理）效率較高，但實現起來也較為復雜。在事件驅動處理的情況下，需要一種發信機制來控制某一特定線程何時應該運行。在 Java 程序中，您可以使用 wait()、notify() 和 notifyAll() 方法向線程發送信號。這些方法允許線程在一個對象上阻塞，直到所需的條件得到滿足為止，然后再次開始運行。這種設計減少了 CPU 占用，因為線程在阻塞時不消耗執行時間，并且可在 notify() 方法被調用時立即喚醒。與輪詢相比，事件驅動方法可以提供更短的響應時間。

創建高效的線程安全類的步驟 
編寫線程安全類的最簡單的方法是用 synchronized 聲明每個方法。雖然這種方案可以消除數據損壞，但它同時也會消除您預期從多線程獲得的任何收益。這樣，您就需要分析并確保在 synchronized 塊內部僅占用最少的執行時間。您必須格外關注訪問緩慢資源 — 文件、目錄、網絡套接字和數據庫 — 的方法，這些方法可能降低您的程序的效率。盡量將對這類資源的訪問放在一個單獨的線程中，最好在任何 synchronized 代碼之外。

一個線程安全類的示例被設計為要處理的文件的中心儲存庫。它與使用 getWork() 和 finishWork() 與 WorkTable 類對接的一組線程一起工作。本例旨在讓您體驗一下全功能的線程安全類，該類使用了 helper 線程和混合同步。請注意繼續添加要處理的新文件的Refresher helper 線程的用法。本例沒有調整到最佳性能，很明顯有許多地方可以改寫以改善性能，比如將 Refresher 線程改為使用 wait()/notify() 方法事件驅動的，改寫 populateTable() 方法以減少列出磁盤上的文件（這是高成本的操作）所產生的影響。

小結 
通過使用可用的全部語言支持，Java 程序中的多線程編程相當簡單。但是，使線程安全類具有較高的效率仍然比較困難。為了改善性能，您必須事先考慮并謹慎使用鎖定功能。

本欄文章均來自于互聯網，版權歸原作者和各發布網站所有，本站收集這些文章僅供學習參考之用。任何人都不能將這些文章用于商業或者其他目的。( ProgramFan.Com )