kapok

http://www.tkk7.com/sgsoft/articles/309.html
為什么會排隊等待？
使用 Java 實現(xiàn)線程
Java 高級多線程支持
避免不提倡使用的方法
調(diào)試線程化的程序
調(diào)試大量的線程
限制線程優(yōu)先級和調(diào)度
小結(jié)

在 Java 程序中使用多線程要比在 C 或 C++ 中容易得多，這是因為 Java 編程語言提供了語言級的支持。本文通過簡單的編程示例來說明 Java 程序中的多線程是多么直觀。讀完本文以后，用戶應該能夠編寫簡單的多線程程序。

為什么會排隊等待？

下面的這個簡單的 Java 程序完成四項不相關(guān)的任務。這樣的程序有單個控制線程，控制在這四個任務之間線性地移動。此外，因為所需的資源 — 打印機、磁盤、數(shù)據(jù)庫和顯示屏 -- 由于硬件和軟件的限制都有內(nèi)在的潛伏時間，所以每項任務都包含明顯的等待時間。因此，程序在訪問數(shù)據(jù)庫之前必須等待打印機完成打印文件的任務，等等。如果您正在等待程序的完成，則這是對計算資源和您的時間的一種拙劣使用。改進此程序的一種方法是使它成為多線程的。

四項不相關(guān)的任務

class myclass { 
static public void main(String args[]) {  
   print_a_file(); 
   manipulate_another_file();
   access_database(); 
   draw_picture_on_screen(); 
   } 
} 
 

在本例中，每項任務在開始之前必須等待前一項任務完成，即使所涉及的任務毫不相關(guān)也是這樣。但是，在現(xiàn)實生活中，我們經(jīng)常使用多線程模型。我們在處理某些任務的同時也可以讓孩子、配偶和父母完成別的任務。例如，我在寫信的同時可能打發(fā)我的兒子去郵局買郵票。用軟件術(shù)語來說，這稱為多個控制（或執(zhí)行）線程。

可以用兩種不同的方法來獲得多個控制線程：

• 多個進程
  在大多數(shù)操作系統(tǒng)中都可以創(chuàng)建多個進程。當一個程序啟動時，它可以為即將開始的每項任務創(chuàng)建一個進程，并允許它們同時運行。當一個程序因等待網(wǎng)絡訪問或用戶輸入而被阻塞時，另一個程序還可以運行，這樣就增加了資源利用率。但是，按照這種方式創(chuàng)建每個進程要付出一定的代價：設置一個進程要占用相當一部分處理器時間和內(nèi)存資源。而且，大多數(shù)操作系統(tǒng)不允許進程訪問其他進程的內(nèi)存空間。因此，進程間的通信很不方便，并且也不會將它自己提供給容易的編程模型。
• 線程
  線程也稱為輕型進程 (LWP)。因為線程只能在單個進程的作用域內(nèi)活動，所以創(chuàng)建線程比創(chuàng)建進程要廉價得多。這樣，因為線程允許協(xié)作和數(shù)據(jù)交換，并且在計算資源方面非常廉價，所以線程比進程更可取。線程需要操作系統(tǒng)的支持，因此不是所有的機器都提供線程。Java 編程語言，作為相當新的一種語言，已將線程支持與語言本身合為一體，這樣就對線程提供了強健的支持。

使用 Java 編程語言實現(xiàn)線程

Java編程語言使多線程如此簡單有效，以致于某些程序員說它實際上是自然的。盡管在 Java 中使用線程比在其他語言中要容易得多，仍然有一些概念需要掌握。要記住的一件重要的事情是 main() 函數(shù)也是一個線程，并可用來做有用的工作。程序員只有在需要多個線程時才需要創(chuàng)建新的線程。

Thread 類
Thread 類是一個具體的類，即不是抽象類，該類封裝了線程的行為。要創(chuàng)建一個線程，程序員必須創(chuàng)建一個從 Thread 類導出的新類。程序員必須覆蓋 Thread 的 run() 函數(shù)來完成有用的工作。用戶并不直接調(diào)用此函數(shù)；而是必須調(diào)用 Thread 的 start() 函數(shù)，該函數(shù)再調(diào)用 run()。下面的代碼說明了它的用法：

創(chuàng)建兩個新線程

import java.util.*; 
class TimePrinter extends Thread {

 int pauseTime; 
String name; 
public TimePrinter(int x, String n) { pauseTime = x; name = n; 
} 

public void run() { 

while(true) { 
try { 
  System.out.println(name + ":" + new Date(System.currentTimeMillis()));

 Thread.sleep(pauseTime); 
} 
catch(Exception e) { 
System.out.println(e); 
}
 } 
} 

static public void main(String args[]) { 
TimePrinter tp1 = new TimePrinter(1000, "Fast Guy"); 

tp1.start(); 

TimePrinter tp2 = new TimePrinter(3000, "Slow Guy"); tp2.start(); 
}
 } 
 

在本例中，我們可以看到一個簡單的程序，它按兩個不同的時間間隔（1 秒和 3 秒）在屏幕上顯示當前時間。這是通過創(chuàng)建兩個新線程來完成的，包括 main() 共三個線程。但是，因為有時要作為線程運行的類可能已經(jīng)是某個類層次的一部分，所以就不能再按這種機制創(chuàng)建線程。雖然在同一個類中可以實現(xiàn)任意數(shù)量的接口，但 Java 編程語言只允許一個類有一個父類。同時，某些程序員避免從 Thread 類導出，因為它強加了類層次。對于這種情況，就要 runnable 接口。

Runnable 接口
此接口只有一個函數(shù)，run()，此函數(shù)必須由實現(xiàn)了此接口的類實現(xiàn)。但是，就運行這個類而論，其語義與前一個示例稍有不同。我們可以用 runnable 接口改寫前一個示例。（不同的部分用黑體表示。）

創(chuàng)建兩個新線程而不強加類層次

import java.util.*; 

class TimePrinter implements Runnable { 

int pauseTime; String name; 

public TimePrinter(int x, String n) { 
pauseTime = x; name = n;
 } 

public void run() { 

while(true) { 

try { System.out.println(name + ":" + new Date(System.currentTimeMillis()));

 Thread.sleep(pauseTime); 
} 
catch(Exception e) {

 System.out.println(e); 
}
 }
 } 

static public void main(String args[]) { 
Thread t1 = new Thread(new TimePrinter(1000, "Fast Guy"));

 t1.start(); 

Thread t2 = new Thread(new TimePrinter(3000, "Slow Guy")); t2.start();

 } 

} 
 

請注意，當使用 runnable 接口時，您不能直接創(chuàng)建所需類的對象并運行它；必須從 Thread 類的一個實例內(nèi)部運行它。許多程序員更喜歡 runnable 接口，因為從 Thread 類繼承會強加類層次。

synchronized 關(guān)鍵字
到目前為止，我們看到的示例都只是以非常簡單的方式來利用線程。只有最小的數(shù)據(jù)流，而且不會出現(xiàn)兩個線程訪問同一個對象的情況。但是，在大多數(shù)有用的程序中，線程之間通常有信息流。試考慮一個金融應用程序，它有一個 Account 對象，如下例中所示：

一個銀行中的多項活動

public class Account {

 String holderName; 
float amount; 

public Account(String name, float amt) { 
holderName = name; 
amount = amt; 

} 

public void deposit(float amt) {

 amount += amt;

 }

 public void withdraw(float amt) {
 amount -= amt;
 }
 public float checkBalance() { 
return amount; 
} } 
 

在此代碼樣例中潛伏著一個錯誤。如果此類用于單線程應用程序，不會有任何問題。但是，在多線程應用程序的情況中，不同的線程就有可能同時訪問同一個 Account 對象，比如說一個聯(lián)合帳戶的所有者在不同的 ATM 上同時進行訪問。在這種情況下，存入和支出就可能以這樣的方式發(fā)生：一個事務被另一個事務覆蓋。這種情況將是災難性的。但是，Java 編程語言提供了一種簡單的機制來防止發(fā)生這種覆蓋。每個對象在運行時都有一個關(guān)聯(lián)的鎖。這個鎖可通過為方法添加關(guān)鍵字 synchronized 來獲得。這樣，修訂過的 Account 對象（如下所示）將不會遭受像數(shù)據(jù)損壞這樣的錯誤：

對一個銀行中的多項活動進行同步處理

public class Account {  String holderName;  float amount;  public Account(String name, float amt) {  holderName = name;  amount = amt;  }  public synchronized void deposit(float amt) {  amount += amt;  }  public synchronized void withdraw(float amt) {  amount -= amt;  }  public float checkBalance() {  return amount;  } }

deposit() 和 withdraw() 函數(shù)都需要這個鎖來進行操作，所以當一個函數(shù)運行時，另一個函數(shù)就被阻塞。請注意， checkBalance() 未作更改，它嚴格是一個讀函數(shù)。因為 checkBalance() 未作同步處理，所以任何其他方法都不會阻塞它，它也不會阻塞任何其他方法，不管那些方法是否進行了同步處理。

Java 編程語言中的高級多線程支持

線程組
線程是被個別創(chuàng)建的，但可以將它們歸類到線程組中，以便于調(diào)試和監(jiān)視。只能在創(chuàng)建線程的同時將它與一個線程組相關(guān)聯(lián)。在使用大量線程的程序中，使用線程組組織線程可能很有幫助。可以將它們看作是計算機上的目錄和文件結(jié)構(gòu)。

線程間發(fā)信
當線程在繼續(xù)執(zhí)行前需要等待一個條件時，僅有 synchronized 關(guān)鍵字是不夠的。雖然 synchronized 關(guān)鍵字阻止并發(fā)更新一個對象，但它沒有實現(xiàn)線程間發(fā)信。Object 類為此提供了三個函數(shù)：wait()、notify() 和 notifyAll()。以全球氣候預測程序為例。這些程序通過將地球分為許多單元，在每個循環(huán)中，每個單元的計算都是隔離進行的，直到這些值趨于穩(wěn)定，然后相鄰單元之間就會交換一些數(shù)據(jù)。所以，從本質(zhì)上講，在每個循環(huán)中各個線程都必須等待所有線程完成各自的任務以后才能進入下一個循環(huán)。這個模型稱為 屏蔽同步，下例說明了這個模型：

屏蔽同步

public class BSync {  int totalThreads;  int currentThreads;  public BSync(int x) {  totalThreads = x; currentThreads = 0;  }  public synchronized void waitForAll() {  currentThreads++;  if(currentThreads < totalThreads) {  try {  wait();  }  catch (Exception e) {}  }  else { currentThreads = 0; notifyAll();  } } }

當對一個線程調(diào)用 wait() 時，該線程就被有效阻塞，只到另一個線程對同一個對象調(diào)用 notify() 或 notifyAll() 為止。因此，在前一個示例中，不同的線程在完成它們的工作以后將調(diào)用 waitForAll() 函數(shù)，最后一個線程將觸發(fā) notifyAll() 函數(shù)，該函數(shù)將釋放所有的線程。第三個函數(shù) notify() 只通知一個正在等待的線程，當對每次只能由一個線程使用的資源進行訪問限制時，這個函數(shù)很有用。但是，不可能預知哪個線程會獲得這個通知，因為這取決于 Java 虛擬機 (JVM) 調(diào)度算法。

將 CPU 讓給另一個線程
當線程放棄某個稀有的資源（如數(shù)據(jù)庫連接或網(wǎng)絡端口）時，它可能調(diào)用 yield() 函數(shù)臨時降低自己的優(yōu)先級，以便某個其他線程能夠運行。

守護線程
有兩類線程：用戶線程和守護線程。用戶線程是那些完成有用工作的線程。 守護線程是那些僅提供輔助功能的線程。Thread 類提供了 setDaemon() 函數(shù)。Java 程序?qū)⑦\行到所有用戶線程終止，然后它將破壞所有的守護線程。在 Java 虛擬機 (JVM) 中，即使在 main 結(jié)束以后，如果另一個用戶線程仍在運行，則程序仍然可以繼續(xù)運行。

避免不提倡使用的方法

不提倡使用的方法是為支持向后兼容性而保留的那些方法，它們在以后的版本中可能出現(xiàn)，也可能不出現(xiàn)。Java 多線程支持在版本 1.1 和版本 1.2 中做了重大修訂，stop()、suspend() 和 resume() 函數(shù)已不提倡使用。這些函數(shù)在 JVM 中可能引入微妙的錯誤。雖然函數(shù)名可能聽起來很誘人，但請抵制誘惑不要使用它們。

調(diào)試線程化的程序

在線程化的程序中，可能發(fā)生的某些常見而討厭的情況是死鎖、活鎖、內(nèi)存損壞和資源耗盡。

死鎖
死鎖可能是多線程程序最常見的問題。當一個線程需要一個資源而另一個線程持有該資源的鎖時，就會發(fā)生死鎖。這種情況通常很難檢測。但是，解決方案卻相當好：在所有的線程中按相同的次序獲取所有資源鎖。例如，如果有四個資源 —A、B、C 和 D — 并且一個線程可能要獲取四個資源中任何一個資源的鎖，則請確保在獲取對 B 的鎖之前首先獲取對 A 的鎖，依此類推。如果“線程 1”希望獲取對 B 和 C 的鎖，而“線程 2”獲取了 A、C 和 D 的鎖，則這一技術(shù)可能導致阻塞，但它永遠不會在這四個鎖上造成死鎖。

活鎖
當一個線程忙于接受新任務以致它永遠沒有機會完成任何任務時，就會發(fā)生活鎖。這個線程最終將超出緩沖區(qū)并導致程序崩潰。試想一個秘書需要錄入一封信，但她一直在忙于接電話，所以這封信永遠不會被錄入。

內(nèi)存損壞
如果明智地使用 synchronized 關(guān)鍵字，則完全可以避免內(nèi)存錯誤這種氣死人的問題。

資源耗盡
某些系統(tǒng)資源是有限的，如文件描述符。多線程程序可能耗盡資源，因為每個線程都可能希望有一個這樣的資源。如果線程數(shù)相當大，或者某個資源的侯選線程數(shù)遠遠超過了可用的資源數(shù)，則最好使用 資源池。一個最好的示例是數(shù)據(jù)庫連接池。只要線程需要使用一個數(shù)據(jù)庫連接，它就從池中取出一個，使用以后再將它返回池中。資源池也稱為 資源庫。

調(diào)試大量的線程

有時一個程序因為有大量的線程在運行而極難調(diào)試。在這種情況下，下面的這個類可能會派上用場：

public class Probe extends Thread {  public Probe() {}  public void run() {  while(true) {  Thread[] x = new Thread[100];  Thread.enumerate(x);  for(int i=0; i<100; i++) {  Thread t = x[i];  if(t == null) break;  else  System.out.println(t.getName() + "\t" + t.getPriority() + "\t" + t.isAlive() + "\t" + t.isDaemon());  } } } }

限制線程優(yōu)先級和調(diào)度

Java 線程模型涉及可以動態(tài)更改的線程優(yōu)先級。本質(zhì)上，線程的優(yōu)先級是從 1 到 10 之間的一個數(shù)字，數(shù)字越大表明任務越緊急。JVM 標準首先調(diào)用優(yōu)先級較高的線程，然后才調(diào)用優(yōu)先級較低的線程。但是，該標準對具有相同優(yōu)先級的線程的處理是隨機的。如何處理這些線程取決于基層的操作系統(tǒng)策略。在某些情況下，優(yōu)先級相同的線程分時運行；在另一些情況下，線程將一直運行到結(jié)束。請記住，Java 支持 10 個優(yōu)先級，基層操作系統(tǒng)支持的優(yōu)先級可能要少得多，這樣會造成一些混亂。因此，只能將優(yōu)先級作為一種很粗略的工具使用。最后的控制可以通過明智地使用 yield() 函數(shù)來完成。通常情況下，請不要依靠線程優(yōu)先級來控制線程的狀態(tài)。

小結(jié)

本文說明了在 Java 程序中如何使用線程。像是否應該使用線程這樣的更重要的問題在很大程序上取決于手頭的應用程序。決定是否在應用程序中使用多線程的一種方法是，估計可以并行運行的代碼量。并記住以下幾點：

• 使用多線程不會增加 CPU 的能力。但是如果使用 JVM 的本地線程實現(xiàn)，則不同的線程可以在不同的處理器上同時運行（在多 CPU 的機器中），從而使多 CPU 機器得到充分利用。
• 如果應用程序是計算密集型的，并受 CPU 功能的制約，則只有多 CPU 機器能夠從更多的線程中受益。
• 當應用程序必須等待緩慢的資源（如網(wǎng)絡連接或數(shù)據(jù)庫連接）時，或者當應用程序是非交互式的時，多線程通常是有利的。

基于 Internet 的軟件有必要是多線程的；否則，用戶將感覺應用程序反映遲鈍。例如，當開發(fā)要支持大量客戶機的服務器時，多線程可以使編程較為容易。在這種情況下，每個線程可以為不同的客戶或客戶組服務，從而縮短了響應時間。

某些程序員可能在 C 和其他語言中使用過線程，在那些語言中對線程沒有語言支持。這些程序員可能通常都被搞得對線程失去了信心。

參考資料

• 請閱讀 Scott Oaks 和 Henry Wong 所著的《Java Threads》，以了解如何充分利用 Java 的線程功能。
• 查找有關(guān) Thread 類和 Java 2 平臺，標準版，API 規(guī)范的其他方面的信息。

作者簡介
Neel V. Kumar 是一位軟件工程師，他有八年的面向?qū)ο缶幊探?jīng)驗，所使用的語言為 C++ 和 Java 編程語言。他出生于 Iowa，目前住在加利福尼亞的 Menlo Park，剛剛涉足電信領(lǐng)域。以前他對許多項目提供過咨詢服務，樂意與他人分享他的知識。可以通過 neelvk@terway.com 與他聯(lián)系。