在進入java平臺的線程對象之前，基于基礎篇(一)的一些問題，我先插入兩個基本概念。

線程的并發(fā)與并行

在單CPU系統(tǒng)中，系統(tǒng)調度在某一時刻只能讓一個線程運行，雖然這種調試機制有多種形式(大多數(shù)是時間片輪巡為主)，但無論如何，要通過不斷切換需要運行的線程讓其運行的方式就叫并發(fā)(concurrent)。而在多CPU系統(tǒng)中，可以讓兩個以上的線程同時運行，這種可以同時讓兩個以上線程同時運行的方式叫做并行(parallel)。

在上面包括以后的所有論述中，請各位朋友諒解，我無法用最準確的詞語來定義儲如并發(fā)和并行這類術語，但我以我的經(jīng)驗能通俗地告訴大家它是怎么一回事，如果您看到我說的一些"標準"文檔上說的不一樣，只要意思一致，那您就不要挑刺了。

JAVA線程對象

現(xiàn)在我們來開始考察JAVA中線程對象。

在JAVA中，要開始一個線程，有兩種方式。一是直接調用Thread實例的start()方法，二是

將Runable實例傳給一個Thread實例然后調用它的start()方法。

在前面已經(jīng)說過，線程對象和線程是兩個完全不同的概念。這里我們再次深入一下，生成一個線程的實例，并不代表啟動了線程。而啟動線程是說在某個線程對象上啟動了該實例對應的線程，當該線程結束后，并不會就立即消失。

對于從很多書籍上可以看到的基礎知識我就不用多說了。既然是基礎知識，我也著重于從普通文檔上讀不到的內容。所以本節(jié)我重點要說的是兩種線程對象產(chǎn)生線程方式的區(qū)別。

class MyThread extends Thread{  
　public int x = 0;  
　public void run(){  
for(int i=0;i<100;i++){  
　 try{  
Thread.sleep(10);  
　 }catch(Exception e){}  
　 System.out.println(x++);  
}  
　}  
} 

如果我們生成MyThread的一個實例，然后調用它的start()方法，那么就產(chǎn)生了這個實例對應的線程:

public class Test {  
　public static void main(String[] args) throws Exception{  
MyThread mt = new MyThread();  
mt.start();  
　}  
} 

不用說，最終會打印出0到99，現(xiàn)在我們稍微玩一點花樣:

public class Test {  
　public static void main(String[] args) throws Exception{  
MyThread mt = new MyThread();  
mt.start();  
System.out.println(101);  
　}  
} 

也不用說，在基礎篇(一)中我們知道由于單CPU的原因，一般會先打印101，然后打印0到99。不過我們可以控制線程讓它按我們的意思來運行:

public class Test {  
　public static void main(String[] args) throws Exception{  
MyThread mt = new MyThread();  
mt.start();  
mt.join();  
System.out.println(101);  
　}  
} 

好了，我們終于看到，mt實例對應的線程(假如我有時說mt線程請你不要怪我，不過我盡量不這么說)。在運行完成后，主線程才打印101。因為我們讓當前線程(這里是主線程)等待mt線程的運行結束。"在線程對象a上調用join()方法，就是讓當前正在執(zhí)行的線程等待線程對象a對應的線程運行完成后才繼續(xù)運行。" 請大家一定要深刻理解并熟記這句話，而我這里引出這個知識點的目的是為了讓你繼續(xù)看下面的例子:

public class Test {  
　public static void main(String[] args) throws Exception{  
MyThread mt = new MyThread();  
mt.start();  
mt.join();  
Thread.sleep(3000);  
mt.start();  
　}  
} 

當線程對象mt運行完成后，我們讓主線程休息一下，然后我們再次在這個線程對象上啟動線程。結果我們看到:

Exception in thread "main" java.lang.IllegalThreadStateException 

也就是這種線程對象一時運行一次完成后，它就再也不能運行第二次了。我們可以看一下它有具體實現(xiàn):

public synchronized void start() {  
　if (started)  
throw new IllegalThreadStateException();  
started = true;  
group.add(this);  
start0();  
　} 

一個Thread的實例一旦調用start()方法，這個實例的started標記就標記為true，事實中不管這個線程后來有沒有執(zhí)行到底，只要調用了一次start()就再也沒有機會運行了，這意味著:

通過Thread實例的start()，一個Thread的實例只能產(chǎn)生一個線程

那么如果要在一個實例上產(chǎn)生多個線程(也就是我們常說的線程池)，我們應該如何做呢?這就是Runnable接口給我們帶來的偉大的功能。

class R implements Runnable{  
　private int x = 0;  
　public void run(){  
for(int i=0;i<100;i++){  
　 try{  
Thread.sleep(10);  
　 }catch(Exception e){}  
　 System.out.println(x++);  
}  
　}  
} 

正如它的名字一樣，Runnable的實例是可運行的，但它自己并不能直接運行，它需要被Thread對象來包裝才行運行:

public class Test {  
　public static void main(String[] args) throws Exception{  
new Thread(new R()).start();  
　}  
} 

當然這個結果和mt.start()沒有什么區(qū)別。但如果我們把一個Runnable實例給Thread對象多次包裝，我們就可以看到它們實際是在同一實例上啟動線程:

public class Test {  
　public static void main(String[] args) throws Exception{  
R r = new R();  
for(int i=0;i<10;i++)  
　 new Thread(r).start();  
　}  
} 

x是實例對象，但結果是x被加到了999，說明這10個線程是在同一個r對象上運行的。請大家注意，因為這個例子是在單CPU上運行的，所以沒有對多個線程同時操作共同的對象進行同步。這里是為了說明的方便而簡化了同步，而真正的環(huán)境中你無法預知程序會在什么環(huán)境下運行，所以一定要考慮同步。

到這里我們做一個完整的例子來說明線程產(chǎn)生的方式不同而生成的線程的區(qū)別:

package debug;  
import java.io.*;  
import java.lang.Thread;  
class MyThread extends Thread{  
　public int x = 0;  
　public void run(){  
System.out.println(++x);  
　}  
}  
class R implements Runnable{  
　private int x = 0;  
　public void run(){  
System.out.println(++x);  
　}  
}  
public class Test {  
　public static void main(String[] args) throws Exception{  
for(int i=0;i<10;i++){  
　 Thread t = new MyThread();  
　 t.start();  
}  
Thread.sleep(10000);//讓上面的線程運行完成  
R r = new R();  
for(int i=0;i<10;i++){  
　 Thread t = new Thread(r);  
　 t.start();  
}  
　}  
} 

上面10個線程對象產(chǎn)生的10個線程運行時打印了10次1。下面10個線程對象產(chǎn)生的10個線程運行時打印了1到10。我們把下面的10個線程稱為同一實例(Runnable實例)的多個線程。

【編輯推薦】

1. Java多線程程序設計詳細解析
2. Java多線程遞歸如何彌補管理漏洞
3. Java多線程程序四步輕松學成
4. Java多線程求和詳細學習筆記
5. Java多線程進程應對同一程序運行資源