A. java線程是什麼
一、操作系統中線程和進程的概念
現在的操作系統是多任務操作系統。多線程是實現多任務的一種方式。
進程是指一個內存中運行的應用程序，每個進程都有自己獨立的一塊內存空間，一個進程中可以啟動多個線程。比如在Windows系統中，一個運行的exe就是一個進程。
線程是指進程中的一個執行流程，一個進程中可以運行多個線程。比如java.exe進程中可以運行很多線程。線程總是屬於某個進程，進程中的多個線程共享進程的內存。
「同時」執行是人的感覺，在線程之間實際上輪換執行。
二、Java中的線程
在Java中，「線程」指兩件不同的事情：
1、java.lang.Thread類的一個實例；
2、線程的執行。
使用java.lang.Thread類或者java.lang.Runnable介面編寫代碼來定義、實例化和啟動新線程。
一個Thread類實例只是一個對象，像Java中的任何其他對象一樣，具有變數和方法，生死於堆上。
Java中，每個線程都有一個調用棧，即使不在程序中創建任何新的線程，線程也在後台運行著。
一個Java應用總是從main()方法開始運行，mian()方法運行在一個線程內，它被稱為主線程。
一旦創建一個新的線程，就產生一個新的調用棧。
線程總體分兩類：用戶線程和守候線程。
當所有用戶線程執行完畢的時候，JVM自動關閉。但是守候線程卻不獨立於JVM，守候線程一般是由操作系統或者用戶自己創建的
B. java多線程,對象鎖是什麼概念
java線程:
1．線程中一些基本術語和概念
1.1線程的幾個狀態
初始化狀態
就緒狀態
運行狀態
阻塞狀態
終止狀態
1.2 Daemon線程
Daemon線程區別一般線程之處是：主程序一旦結束，Daemon線程就會結束。
1.3鎖的定義
為了協調多個並發運行的線程使用共享資源才引入了鎖的概念。
1.4死鎖
任何多線程應用程序都有死鎖風險。當一組線程中的每一個都在等待一個只
有該組中另一個線程才能引起的事件時，我們就說這組線程死鎖了。換一個說法
就是一組線程中的每一個成員都在等待別的成員佔有的資源時候，就可以說這組
線程進入了死鎖。死鎖的最簡單情形是：線程 A 持有對象 X 的獨占鎖，並且
在等待對象 Y 的鎖，而線程 B 持有對象 Y 的獨占鎖，卻在等待對象 X 的鎖。
除非有某種方法來打破對鎖的等待（Java 鎖定不支持這種方法），否則死鎖的線
程將永遠等下去。
1.5.Java對象關於鎖的幾個方法
1.5.1 wait方法
wait方法是java根對象Object含有的方法，表示等待獲取某個鎖。在wait方法進入前，會釋放相應的鎖，在wait方法返回時，會再次獲得某個鎖。
如果wait()方法不帶有參數，那隻有當持有該對象鎖的其他線程調用了notify或者notifyAll方法，才有可能再次獲得該對象的鎖。
如果wait()方法帶有參數，比如：wait(10)，那當持有該對象鎖的其他線程調用了notify或者notifyAll方法，或者指定時間已經過去了，才有可能再次獲得該對象的鎖。
參考 thread.lock.SleepAndWait
1.5.2 notify/notifyAll方法
這里我就不再說明了。哈哈，偷點懶。
1.5.3 yield方法
yield()會自動放棄CPU，有時比sleep更能提升性能。
1.6鎖對象(實例方法的鎖)
在同步代碼塊中使用鎖的時候，擔當鎖的對象可以是這個代碼所在對象本身或者一個單獨的對象擔任，但是一定要確保鎖對象不能為空。如果對一個null對象加鎖，會產生異常的。原則上不要選擇一個可能在鎖的作用域中會改變值的實例變數作為鎖對象。
鎖對象,一種是對象自己擔任，一種是定義一個普通的對象作為private property來擔任，另外一種是建立一個新的類，然後用該類的實例來擔任。
參考 :
thread.lock.UseSelfAsLock，使用對象自己做鎖對象
thread.lock.UseObjAsLock 使用一個實例對象作鎖對象
thread.lock.UseAFinalObjAsLock使用常量對象作為一個鎖對象
1.7類鎖
實例方法存在同步的問題，同樣，類方法也存在需要同步的情形。一般類方法的類鎖是一個static object來擔任的。當然也可以採用類本身的類對象來作為類鎖。
一個類的實例方法可以獲得該類實例鎖，還可以嘗試去訪問類方法，包含類同步方法，去獲得類鎖。
一個類的類方法，可以嘗試獲得類鎖，但是不可以嘗試直接獲得實例鎖。需要先生成一個實例，然後在申請獲得這個實例的實例鎖。
參考
thread.lock.UseStaticObjAsStaticLock 使用類的屬性對象作為類鎖。
thread.lock.UseClassAsStaticLock使用類的類對象作為類鎖
1.8.線程安全方法與線程不安全方法
如果一個對象的所有的public方法都是同步方法，也就是說是public方法是線程安全的，那該對象的private方法，在不考慮繼承的情況下，可以設置為不是線程安全的方法。
參考 thread.lock.SynMethrodAndNotSynMethrod
1.9類鎖和實例鎖混合使用
在實例方法中混合使用類鎖和實例鎖；可以根據前面說的那樣使用實例鎖和類鎖。
在類方法中混合使用類鎖和實例鎖，可以根據前面說的那樣使用類鎖，為了使用實例鎖，先得生成一個實例，然後實例鎖。
參考 thread.lock.StaticLockAndObjLock
1.10鎖的粒度問題。
為了解決對象鎖的粒度過粗，會導死鎖出現的可能性加大，鎖的粒度過細，會程序開發維護的工作加大。對於鎖的粒度大小，這完全要根據實際開發需要來考慮，很難有一個統一的標准。
1.11.讀寫鎖
一個讀寫鎖支持多個線程同時訪問一個對象，但是在同一時刻只有一個線程可以修改此對象，並且在訪問進行時不能修改。
有2種調度策略，一種是讀鎖優先，另外就是寫鎖優先。
參考 thread.lock.ReadWriteLock
1.12 volatile
在Java中設置變數值的操作，除了long和double類型的變數外都是原子操作，也就是說，對於變數值的簡單讀寫操作沒有必要進行同步。這在JVM 1.2之前，Java的內存模型實現總是從主存讀取變數，是不需要進行特別的注意的。而隨著JVM的成熟和優化，現在在多線程環境下volatile關鍵字的使用變得非常重要。在當前的Java內存模型下，線程可以把變數保存在本地內存（比如機器的寄存器）中，而不是直接在主存中進行讀寫。這就可能造成一個線程在主存中修改了一個變數的值，而另外一個線程還繼續使用它在寄存器中的變數值的拷貝，造成數據的不一致。要解決這個問題，只需要像在本程序中的這樣，把該變數聲明為volatile（不穩定的）即可，這就指示JVM，這個變數是不穩定的，每次使用它都到主存中進行讀取。一般說來，多任務環境下各任務間共享的標志都應該加volatile修飾。
2．線程之間的通訊
在其他語言中，線程之間可以通過消息隊列，共享內存，管道等方式來實現
線程之間的通訊，但是java中可以不採用這樣方式，關注的是線程之間的同步。
只要保證相關方法運行的線程安全，信息共享是自然就可以顯現了。
2.1屏障
屏障就是這樣的一個等待點: 一組線程在這一點被同步，這些線程合並各自的結果或者運行到整體任務的下一階段。
參考：
thread.lock. BarrierUseExample
thread.lock.Barrier
2.2.鎖工具類
提供對線程鎖的獲取，釋放功能。展示了鎖的獲取釋放過程。可以作為一個工具類來使用。
參考：thread.lock. BusyFlag
2.3.條件變數
條件變數是POSIX線程模型提供的一種同步類型，和java中的等待通知機制類似。
雖然java中已經有了等待通知機制，但是為了減少在notify/notifyAll方法中
線程調度的開銷，把一些不需要激活的線程屏蔽出去，引入了條件變數。
Java中2個（多個）條件變數可以是同一個互斥體（鎖對象）。
參考：thread.lock.CondVar 條件變數類
常見的應用情形：
一個鎖控制多個信號通道（例如：多個變數），雖然可以採用簡單java等待通知機制，但是線程調度效率不高，而且線程可讀性也不是太好，這時候可以採用創建一個鎖對象(BusyFlag實例)，同時使用這個BusyFlag實例來創建多個條件變數(CondVar 實例)。
經常使用到CondVar類的地方是緩沖區管理，比如：管道操作之類的。先創建一個BusyFlag實例，然後創建CondVar 實例，用這個條件變數描述緩沖區是否為空，另外創建CondVar 實例作條件變數述緩沖區是否滿。
現實中，馬路的紅綠燈，就可以採用條件變數來描述。
3. Java線程調度
3.1 Java優先順序
java的優先順序別共有10種，加上虛擬機自己使用的優先順序別=0這種，總共11種。
大多數情況來說，java線程的優先順序設置越高（最高=10），那線程越優先運行。
3.2. 綠色線程
線程運行在虛擬機內，操作系統根本不知道這類線程的存在。
線程是由虛擬機調度的。
3.3 本地線程
線程是由運行虛擬機的操作系統完成的。
3.4 Windows本地線程
操作系統，完全能夠看得到虛擬機內的每一個線程，同時虛擬機的線程和操作系統的線程是一一對應的。Java的線程調度室由操作系統底層線程決定的。
在win32平台下，windows線程只有6個優先順序別。和java線程優先順序別對應如下：
Java線程優先順序 Windows 95/nt/2000線程優先順序
0 THREAD_ PRIORITY_IDLE
1(Thread.MIN_PRIORITY) THREAD_ PRIORITY_LOWEST
2 THREAD_ PRIORITY_LOWEST
3 THREAD_ PRIORITY_BELOW_NORMAL
4 THREAD_ PRIORITY_BELOW_NORMAL
5 (Thread.NORM_PRIORITY) THREAD_ PRIORITY _NORMAL
6 THREAD_ PRIORITY _ABOVE_NORMAL
7 THREAD_ PRIORITY _ABOVE_NORMA
8 THREAD_ PRIORITY _HIGHEST
9 THREAD_ PRIORITY _HIGHEST
10 (Thread.MAX_PRIORITY) THREAD_ PRIORITY _CRITICAL
3.5線程優先順序倒置與繼承
如果一個線程持有鎖(假設該線程名字=ThreadA,優先順序別=5)，另外一個線程(假設該線程名字=ThreadB,優先順序別=7),現在該線程(ThreadA)處於運行狀態，但是線程ThreadB申請需要持有ThreadA所獲得的鎖，這時候，為了避免死鎖，線程A提高其運行的優先順序別（提高到ThreadB的優先順序別=7）,而線程ThreadB為了等待獲得鎖，降低線程優先順序別(降低到ThreadA原來的優先順序別=5).
上述的這種情況，對於ThreadA,繼承了ThreadB的優先順序別，這成為優先順序別的繼承；對於ThreadB暫時降低了優先順序別，成為優先順序別的倒置。
當然，一旦線程ThreadA持有的鎖釋放了，其優先順序別也會回到原來的優先順序別（優先順序別=5）。線程ThreadB獲得了相應的鎖，那優先順序別也會恢復到與原來的值(優先順序別=7)。
3.6循環調度
具有同樣優先順序的線程相互搶占成為循環調度。
4.線程池
創建一個線程也是需要一定代價的,為了降低這個代價，採用了和普通對象池的思想建立線程池，以供系統使用。
線程消耗包括內存和其它系統資源在內的大量資源。除了 Thread 對象所需的內存之外，每個線程都需要兩個可能很大的執行調用堆棧。除此以外，JVM 可能會為每個 Java 線程創建一個本機線程，這些本機線程將消耗額外的系統資源。最後，雖然線程之間切換的調度開銷很小，但如果有很多線程，環境切換也可能嚴重地影響程序的性能。
使用線程池的方式是，先建立對象池，然後申請使用線程，程序線程運行，運行完畢，把線程返回線程池。
使用線程池的風險：同步錯誤和死鎖，與池有關的死鎖、資源不足和線程泄漏。
大家有空可以研究一下tomcat的線程池實現原理思想。
實際上是tomcat已經在從線程池的使用線程時候加上了事件處理機制。
個人認為，線程池之類的實現，一般不要自己實現，因為自己實現主要是穩定性等方面可能作的不夠好。
可以參考 apache的jakarta-tomcat-5.5.6的相關代碼，具體是：
jakarta-tomcat-connectors\util\java\org\apache\tomcat\util\threads的相關代碼
5工作隊列
使用工作隊列的好處是不象直接使用線程池那樣，當線城池中沒有線程可以使用的時
候，使用者需要處於等待狀態，不能進行其他任務的處理。
工作隊列的工作原理是：
採用後台線程處理方式，客戶端把任務提交給工作隊列，工作隊列有一組內部可以工作線程，這些工作線程從工作隊列中取出任務運行，一個任務完成後，就從隊列獲取下一個任務進行處理。當工作隊列中沒有任務可以處理時候，工作線程就處於等待狀態，直到獲得新的任務時候，才進行新的處理。
C. 請問如何用JAVA多線程寫一個紅黃綠依次亮的交通燈程序
import java.awt.*;
import java.awt.event.*;
public class JiaoTong extends Frame {
boolean redStatus=false,greenStatus=false,yellowStatus=false;
int j=0;
public void paint(Graphics g) {
Color c=g.getColor();
if(redStatus==true)
{j++;
g.setColor(Color.RED);
g.fillOval(100,50, 50,50);
g.drawString("紅燈亮了"+j+"秒", 100, 120);
}
else
{
g.setColor(Color.BLACK);
g.fillOval(100,50, 50,50);
}
if(yellowStatus==true){
j++;
g.setColor(Color.YELLOW);
g.fillOval(100, 150, 50, 50);
g.drawString("黃燈注意啦"+j+"秒", 100, 220);
}
else
{
g.setColor(Color.BLACK);
g.fillOval(100, 150, 50, 50);
}
if(greenStatus==true){
j++;
g.setColor(Color.GREEN);
g.fillOval(100, 250, 50, 50);
g.drawString("綠燈行"+j+"秒", 100, 320);
}
else
{
g.setColor(Color.BLACK);
g.fillOval(100, 250, 50, 50);
}
g.setColor(c);
}
public void Lauch() {
setTitle("交通燈指示");
setSize(300, 400);
setBackground(Color.BLACK);
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
setVisible(true);
new Thread(new PaintThread()).start();
}
public static void main(String[] args) {
JiaoTong a=new JiaoTong();
a.Lauch();
}
public class PaintThread implements Runnable
{
public void run() {
for(int i=0;i<80;i++){
switch (i) {
case 0:
j=0;
redStatus=true;
greenStatus=false;
yellowStatus=false;
break;
case 40:
j=0;
redStatus=false;
greenStatus=false;
yellowStatus=true;
break;
case 50:
j=0;
redStatus=false;
greenStatus=true;
yellowStatus=false;
break;
default:
break;
}
repaint();
if(i==79)
i=-1;
try
{
Thread.sleep(1000);
}
catch(InterruptedException e)
{
e.printStackTrace();
}
}
}
}
}
D. java中的線程是個什麼具體的內容
這么說吧，電腦系統里有一個任務管理器，任務管理器中有許多進程，一個進程的下面又有很多線程。就是這個意思啊。
例如JAVA的main方法就是一個主線程，程序的執行順序是自上而下的，如果這個程序沒有在這個主線程上創建一個新的線程的話，程序就自上而下的執行，直到程序執行完閉。
如果你在這個主線程上，也就是main方法里創建了一個新的線程，那麼這個時候就有兩個線程，新的線程開始執行，這個時候主線程並不是停止了，而是一樣的繼續自上而下的執行，這個時候就有兩條線程在執行代碼了。
比如有一輛大卡車，遇到到了一個叉路口，這時大卡車就相當於主線程，這個時候只通往一條道路了，如果在叉路口上大卡車里出來了一輛小車，這個時候小車和大卡車分別向兩條路上行駛，而並非大卡車會停下來，這個時候的狀態就是兩個線程在同時運行。
雖說這個比喻不是很好，但很形象！
說白了，我們以前寫的那些簡單的程序就只有一個線程，就是主線程（main方法），不管有多少判斷，循環，它都是自上而下的執行，如果創建了另一個新的線程，這個時候就有兩條線同時執行各自的任務了
E. java 中線程是什麼東東
線程是進程中的一個實體，是被系統獨立調度和分派的基本單位，線程自己不擁有系統資源，只擁有一點在運行中必不可少的資源，但它可與同屬一個進程的其它線程共享進程所擁有的全部資源。一個線程可以創建和撤消另一個線程，同一進程中的多個線程之間可以並發執行。由於線程之間的相互制約，致使線程在運行中呈現出間斷性。線程也有就緒、阻塞和運行三種基本狀態。
線程是程序中一個單一的順序控制流程.在單個程序中同時運行多個線程完成不同的工作,稱為多線程.
線程和進程的區別在於,子進程和父進程有不同的代碼和數據空間,而多個線程則共享數據空間,每個線程有自己的執行堆棧和程序計數器為其執行上下文.多線程主要是為了節約CPU時間,發揮利用,根據具體情況而定. 線程的運行中需要使用計算機的內存資源和CPU
F. java 線程實現一個紅綠燈問題
關鍵是啟動一個線程式控制制顏色。代碼如下。
import java.applet.Applet;
import java.awt.Color;
import java.awt.Graphics;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheledExecutorService;
import java.util.concurrent.TimeUnit;
public class Signal extends Applet {
int width = 200, height = 240;
int w = 50, h = 50;
int x = (width - w) / 2, y1 = (height - h * 3) / 3, y2 = y1 + h, y3 = y2 + h;
Color c = Color.RED;
@Override
public void init() {
ScheledExecutorService exec = Executors.newScheledThreadPool(1);
exec.scheleAtFixedRate(new Runnable() {
@Override
public void run() {
if (c == Color.RED) {
c = Color.YELLOW;
} else if (c == Color.YELLOW) {
c = Color.GREEN;
} else if (c == Color.GREEN) {
c = Color.RED;
}
repaint();
}
}, 5, 5, TimeUnit.SECONDS);
}
@Override
public void paint(Graphics g) {
setBackground(Color.white);
// all gray
g.setColor(Color.LIGHT_GRAY);
g.fillOval(x, y1, w, h);
g.fillOval(x, y2, w, h);
g.fillOval(x, y3, w, h);
if (c == Color.RED) {
g.setColor(Color.RED);
g.fillOval(x, y1, w, h);
} else if (c == Color.YELLOW) {
g.setColor(Color.YELLOW);
g.fillOval(x, y2, w, h);
} else if (c == Color.GREEN) {
g.setColor(Color.GREEN);
g.fillOval(x, y3, w, h);
}
}
}
G. JAVA線程的機制有哪些
Java的線程機制 摘 要： 多線程機制是Java的重要技術，闡述了線程和進程的差別；Java中線程4個狀態之間的轉換；並結合例子說明了兩種創建線程的方法。 線程是指程序中能順序執行的一個序列。一個線程只有一個入口點� 但可能有幾個出口點� 不過，每個時刻的執行點總是只有一個。線程是不能獨立運行的程序，而只是某個整體程序內部的一個順序執行流。 多線程是Java的一個重要特點。如果一個程序是單線程的，那麼，任何時刻都只有一個執行點。這種單線程執行方法使系統運行效率低，而且，由於必須依靠中斷來處理輸入／輸出。所以，當出現頻繁輸入／輸出或者有優先順序較低的中斷請求時，實時性就變得很差。多線程系統可以避免這個缺點。所謂多線程，就是通過系統的調度使幾個具有不同功能的程序流即線程同時並行地運行。 在單處理器計算機系統中，實際上是不可能使多個線程真正並行運行的，而要通過系統用極短的時間、極快的速度對多個線程進行切換，宏觀上形成多個線程並發執行的效果。 １ 線程和進程機制上的差別 線程和進程很相象,它們都是程序的一個順序執行序列,但兩者又有區別。進程是一個實體,每個進程有自己獨立的狀態,並有自己的專用數據段，創建進程時, 必須建立和復制其專用數據段，線程則互相共享數據段。同一個程序中的所有線程只有一個數據段, 所以, 創建線程時不必重新建立和復制數據段。由於數據段建立和復制這方面的差異，使線程的建立和線程間的切換速度大大優於進程,另一方面,線程又具備進程的大多數優點。 假設銀行系統辦理存款和取款手續,將帳本看成數據段。如果按進程這種機制,那麼,當儲戶去存／取款時,銀行應先把帳本復制一遍,為儲戶建立一個獨立的帳本再結算。如果按線程機制, 那麼,銀行里所有的出納員都用同一個帳本,儲戶來辦存／取款時,也從這個帳本直接結算。用線程機制省去了數據段復制這一步顯然是線程獨具的特點。 由於多個線程共享一個數據段,所以，也出現了數據訪問過程的互斥和同步問題,這使系統管理功能變得相對復雜。 總的來說，一個多線程系統在提高系統的輸入／輸出速度、有效利用系統資源、改善計算機通信功能以及發揮多處理器硬體功能方面顯示了很大優勢。因此，一些最新的操作系統如Windows95、Windows98、Windows NT等都提供了對多線程的支持。但是，在多線程操作系統下設計多線程的程序仍然是一個比較復雜和困難的工作。由於需要解決對數據段的共享，所以，原則上應該從程序設計角度採用加鎖和釋放措施，稍有不慎，便會使系統產生管理上的混亂。 而Java從語言一級提供對多線程的支持，這樣，可由語言和運行系統聯合提供對共享數據段的管理功能和同步機制，使得多線程並行程序設計相對比較容易。 ２ Java線程的生命周期 每個線程都是和生命周期相聯系的，一個生命周期含有多個狀態，這些狀態間可以互相轉化。 Java的線程的生命周期可以分為4個狀態;創建（new)狀態;可運行(runnable)狀態;不執行(notrunnable)狀態;消亡(dead)狀態。 創建狀態是指創建一個線程對應的對象的過程，Java系統中,些對象都是從Java．lang包內一個稱為Thread的類用關鍵字new創建的。剛創建的線程不能執行,必須向系統進行注冊、分配必要的資源後才能進入可運行狀態，這個步驟是由start操作完成的,而處於可運行狀態的線程也未必一定處於運行中,它有可能由於外部的I/O請求而處於不運行狀態。進入消亡狀態後,此線程就不再存在了。 一個線程創建之後，總是處於其生命周期的4個狀態之一中，線程的狀態表明此線程當前正在進行的活動,而線程的狀態是可以通過程序來進行控制的,就是說,可以對線程進行操作來改變狀態。 這些操作包括啟動(start)、終止(stop)、睡眠(sleep)、掛起(suspend)、恢復(resume)、等待(wait)和通知(notify)。每一個操作都對應了一個方法� 這些方法是由軟體包Java．lang提供的。通過各種操作,線程的4個狀態之間可按圖1所示進行轉換。 2.1 創建(new)狀態 如果創建了一個線程而沒有啟動它,那麼，此線程就處於創建狀態。比如，下述語句執行以後，使系統有了一個處於創建狀態的線程myThread:� Thread myThread=new MyThreadClass(); 其中，MyThreadClass()是Thread的子類，而Thread是由Java系統的Java．lang軟體包提供的。處於創建狀態的線程還沒有獲得應有的資源,所以，這是一個空的線程,線程只有通過啟動後,系統才會為它分配資源。對處於創建狀態的線程可以進行兩種操作： 一是啟動(start)操作,使其進入可運行狀態；二是終止(stop)操作,使其進入消亡狀態。如果進入到消亡狀態,那麼，此後這個線程就不能進入其它狀態,也就是說，它不復存在了。 start方法是對應啟動操作的方法,其具體功能是為線程分配必要的系統資源,將線程設置為可運行狀態,從而可以使系統調度這個線程。 2.2 可運行(runnable)狀態 如果對一個處於創建狀態的線程進行啟動操作,則此線程便進入可運行狀態。比如,用下列語句� myThread.start();� � 則使線程myThread進入可運行狀態。上述語句實質上是調用了線程體即run()方法,注意，run()方法包含在myThread線程中,也就是先由java．lang包的Thread類將run()方法傳遞給子類MyThreadClass(),再通過創建線程由子類MyThreadClass,傳遞給線程myThread。 線程處於可運行狀態只說明它具備了運行條件,但可運行狀態並不一定是運行狀態,因為在單處理器系統中運行多線程程序,實際上在一個時間點只有一個線程在運行,而系統中往往有多個線程同時處於可運行狀態,系統通過快速切換和調度使所有可運行線程共享處理器,造成宏觀上的多線程並發運行。可見,一個線程是否處於運行狀, 除了必須處於可運行狀態外,還取決於系統的調度。 在可運行狀態可以進行多種操作，最通常的是從run()方法正常退出而使線程結束,進入消亡狀態。 此, 還可以有如下操作� 掛起操作,通過調用suspend方法來實現； 睡眠操作,通過調用sleep方法來實現； 等待操作,通過調用wait方法來實現； 退讓操作,通過調用yield方法來實現； 終止操作,通過調用stop方法來實現。 前面三種操作都會使一個處於可運行狀態的線程進入不可運行狀態。比如，仍以myThread線程為例,當其處於可運行狀態後,再用如下語句� myThread.sleep (5000); 則調用sleep方法使myThread線程睡眠5s(5000ms)。這5s內,此線程不能被系統調度運行,只有過5s後,myThread線程才會醒來並自動回到可運行狀態。 如果一個線程被執行掛起操作而轉到不可運行狀態,則必須通過調用恢復(resume)操作,才能使這個線程再回到可運行狀態。 退讓操作是使某個線程把CPU控制權提前轉交給同級優先權的其他線程。 對可運行狀態的線程也可以通過調用stop方法使其進入消亡狀態。 2.3 不可運行(not runnable)狀態 不可運行狀態都是由可運行狀態轉變來的。一個處於可運行狀態的線程,如果遇到掛起(suspend)操作、睡眠(sleep)操作或者等待(wait)操作,就會進入不可運行狀態。 另外,如果一個線程是和I/O操作有關的,那麼，在執行I/O指令時，由於外設速度遠遠低於處理器速度而使線程受到阻, 從而進入不可運行狀態，只有外設完成輸入／輸出之後,才會自動回到可運行狀態。線程進入不可運行狀態後,還可以再回到可運行狀態,通常有三種途徑使其恢復到可運行狀態。 一是自動恢復。通過睡眠(sleep)操作進入不可運行狀態的線程會在過了指定睡眠時間以後自動恢復到可運行狀態,由於I/O阻塞而進入不可運行狀態的線程在外設完成I/O操作後,自動恢復到可運行狀態。 二是用恢復(resume)方法使其恢復。如果一個線程由於掛起(suspend)操作而從可運行狀態進入不可運行狀態,那麼，必須用恢復(resume)操作使其再恢復到可運行狀態。 三是用通知(notify或notifyAll)方法使其恢復。如果一個處於可運行狀態的線程由於等待(wait)操作而轉入不可運行狀態,那麼，必須通過調用notify方法或notifyAll方法才能使其恢復到可運行狀態,採用等待操作往往是由於線程需要等待某個條件變數,當獲得此條件變數後,便可由notify或ontifyAll方法使線程恢復到可運行狀態。 恢復到可運行狀態的每一種途徑都是有針對性的,不能交叉。比如，對由於阻塞而進入不可運行狀態的線程採用恢復操作將是無效的。 在不可運行狀態,也可由終止(stop)操作使其進入消亡狀態。 2.4 消亡(dead)狀態 一個線程可以由其他任何一個狀態通過終止(stop)操作而進入消亡狀態。 線程一旦進入消亡狀態,那它就不再存在了,所以也不可能再轉到其它狀態。 通常,在一個應用程序運行時,如果通過其它外部命令終止當前應用程序,那麼就會調用(stop)方法終止線程。但是，最正常、最常見的途徑是由於線程在可運行狀態正常完成自身的任務而″壽終正寢″,從而進入消亡狀態,這個完成任務的動作是由run方法實現的。 ３ Java線程的兩種創建途徑 一種途徑是通過對Thread的繼承來派生一個子類,再由此子類生成一個對象來實現線程的創建，這是比較簡單直接的辦法。Thread類包含在系統API提供的8個軟體包之一Java．lang中,Thread類中包含了很多與線程有關的方, 其中,一個名為run的方法就是用來實現線程行為的。比如:� １ import java.lang.*� ／／引用lang包 ２ class Mango exteds Thread { ３ public void run() { ４ ．．．．．． ５ �} ６ �} 上述程序段中，第１行語句引用軟體包lang，這樣做是為了給編譯器一個信息，從而使後面程序中有關lang包中的方法可直接用方法名，而不必帶前綴「Java．lang」。第２行語句是從lang包Thread派生一個子類Mango, 而這個子類中提供了run方法的實現,這樣,運行時，將由子類Mango 的 run方法置換父類Thread的run方法。 不過這一步還沒有創建線, 必須由子類生成一個對象，並且進行啟動操作，這樣才能得到一個處於可運行狀態的線程。生成對象其實就是完成線程的創建,而啟動是對已創建的線程進行操作。具體語句如下:� Mango t=new Mango(); � t.start(); � 上面先用關鍵字new使線程進入創建狀態,又調用start()方法使線程進入可運行狀態。注意，start()方法是由Thread繼承給子類Mango、然後又在生成對象時由對象t從類Mango得到的。 另一種途徑是通過一個類去繼承介面runnable來實現線程的創建� 而這個類必須提供runnable介面中定義的方法run()的實現。runnable是Java．lang包中的一個介面，在runnable介面中,只定義了一個抽象方法run()。所以，如用這種途徑來創建線程,則應先由一個類連接介面runnable，並且提供run()方法的實現。比如，下面的程序段實現了與介面的連接。 １ public class xyz implements Runnable{ ２ int i; � ３ public voed run(){ ４ while (true){ � ５ System.out.println("Hello"+i++); ６ � } ７ � } ８ � } 然後再創建一個線程� runnable r=new xyz(); � Thread t=new Thread(r); 這種途徑創建線程比第一種途徑靈活。當一個類既需要繼承一個父類又要由此創建一個線程時，由於Java不支持多重繼承，這樣，用第一種途徑將行不通,因為，按此思路創建線程也是以繼承的方法實現的。 於是，就需要一個類既繼承Thread類,又繼承另一個父類。但用介面方法卻能實現這個目標。 ４ 線程的啟動和終止 Thread的start()方法對應於啟動操作,它完成兩方面的功能：一方面是為線程分配必要的資源,使線程處於可運行狀態,另一方面是調用線程的run()方法置換Thread的中run()方法或者置換runnable中的run()方法來運行線程。 使用start()方法的語句很簡單,即： ThreadName.start(); 下面的程序段先創建並啟動線程myThread, 然後使用sleep()方法讓其睡眠20000ms即20s，使其處於不可運行狀態,過20s後,線程又自動恢復到可運行狀態。 Thread MyThread=new MyThreadClass(); MyThread.start();� � try{ � MyThread.sleep(20000); �} catch(InterrujptedException e){ }
H. 如何看待Java綠色線程的相關應用效果
Java綠色線程到底是一個怎麼回事呢？這些問題需要我們從本質中看問題 。下面我們就來看看Java綠色線程（Green Thread）是一個相對於操作系統線程（Native Thread）的概念 。
操作系統線程（Native Thread）的意思就是，程序裡面的線程會真正映射到操作系統的線程，線程的運行和調度都是由操作系統控制的
Java綠色線程（Green Thread）的意思是，程序裡面的線程不會真正映射到操作系統的線程，而是由語言運行平台自身來調度 。
當前版本的Python語言的線程就可以映射到操作系統線程 。當前版本的Ruby語言的線程就屬於綠色線程，無法映射到操作系統的線程，因此Ruby語言的線程的運行速度比較慢 。
Java線程同步如何才能排除阻塞
Java線程函數關鍵代碼詳細講述
Java線程同步引用基本代碼介紹
Java線程式控制制權源代碼的深入探討
Java線程同步問題在實踐中尋找答案
難道說，Java綠色線程要比操作系統線程要慢嗎？當然不是這樣 。事實上，情況可能正好相反 。Ruby是一個特殊的例子 。線程調度器並不是很成熟 。
目前，線程的流行實現模型就是Java綠色線程 。比如，stackless Python，就引入了更加輕量的綠色線程概念 。在線程並發編程方面，無論是運行速度還是並發負載上，都優於Python 。
另一個更著名的例子就是ErLang（愛立信公司開發的一種開源語言） 。
ErLang的Java綠色線程概念非常徹底 。ErLang的線程不叫Thread，而是叫做Process 。這很容易和進程混淆起來 。這里要注意區分一下 。
ErLang Process之間根本就不需要同步 。因為ErLang語言的所有變數都是final的，不允許變數的值發生任何變化 。因此根本就不需要同步 。
final變數的另一個好處就是，對象之間不可能出現交叉引用，不可能構成一種環狀的關聯，對象之間的關聯都是單向的，樹狀的 。因此，內存垃圾回收的演算法效率也非常高 。這就讓ErLang能夠達到Soft
Real Time（軟實時）的效果 。這對於一門支持內存垃圾回收的語言來說，可不是一件容易的事情 。
I. 簡述Java語言中線程的特點。
線程化是允許多個活動共存於一個進程中的工具。大多數現代的操作系統都支持線程，而且線程的概念以各種形式已存在了好多年。Java 是第一個在語言本身中顯式地包含線程的主流編程語言，它沒有把線程化看作是底層操作系統的工具。
有時候，線程也稱作輕量級進程。就象進程一樣，線程在程序中是獨立的、並發的執行路徑，每個線程有它自己的堆棧、自己的程序計數器和自己的局部變數。但是，與分隔的進程相比，進程中的線程之間的隔離程度要小。它們共享內存、文件句柄和其它每個進程應有的狀態。
進程可以支持多個線程，它們看似同時執行，但互相之間並不同步。一個進程中的多個線程共享相同的內存地址空間，這就意味著它們可以訪問相同的變數和對象，而且它們從同一堆中分配對象。盡管這讓線程之間共享信息變得更容易，但您必須小心，確保它們不會妨礙同一進程里的其它線程。
Java 線程工具和 API 看似簡單。但是，編寫有效使用線程的復雜程序並不十分容易。因為有多個線程共存在相同的內存空間中並共享相同的變數，所以您必須小心，確保您的線程不會互相干擾。
每個 Java 程序都使用線程
每個 Java 程序都至少有一個線程 ― 主線程。當一個 Java 程序啟動時，JVM 會創建主線程，並在該線程中調用程序的 main() 方法。
JVM 還創建了其它線程，您通常都看不到它們 ― 例如，與垃圾收集、對象終止和其它 JVM 內務處理任務相關的線程。其它工具也創建線程，如 AWT（抽象窗口工具箱（Abstract Windowing Toolkit））或 Swing UI 工具箱、servlet 容器、應用程序伺服器和 RMI（遠程方法調用（Remote Method Invocation））。