java線程類
『壹』 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，守候線程一般是由操作系統或者用戶自己創建的
『貳』 java中如何啟動一個新的線程
java開啟新線程的三種方法：
方法1：繼承Thread類
1）：定義一個繼承自Java.lang.Thread類的類A.
2）：覆蓋A類Thread類中的run方法。
3）：我們編寫需要在run方法中執行的操作：run方法中的代碼，線程執行體。
4）：在main方法（線程）中，創建一個線程對象並啟動線程。
(1)創建線程類對象:
A類 a = new A類();
(2)調用線程對象的start方法:
a.start();//啟動一個線程
注意：不要調用run方法。如果run方法被稱為對象調用方法，則仍然只有一個線程，並且沒有啟動新線程。
創建啟動線程實例：
(2)java線程類擴展閱讀：
啟動新線程的兩種方式對比
繼承方式:
1):從設計上分析，Java中類是單繼承的,如果繼承了Thread了,該類就不能再有其他的直接父類了.
2):從操作上分析,繼承方式更簡單,獲取線程名字也簡單.(操作上,更簡單)
3):從多線程共享同一個資源上分析,繼承方式不能做到.
實現方式:
1):從設計上分析，Java中類可以多實現介面,此時該類還可以繼承其他類,並且還可以實現其他介面，設計更為合理.
2):從操作上分析,實現方式稍微復雜點,獲取線程名字也比較復雜,得使用Thread.currentThread()來獲取當前線程的引用.
3):從多線程共享同一個資源上分析,實現方式可以做到(是否共享同一個資源).
補充：實現方式獲取線程名字：
String name = Thread.currentThread().getName();
『叄』 Java多線程程序設計初步入門
在Java語言產生前 傳統的程序設計語言的程序同一時刻只能單任務操作 效率非常低 例如程序往往在接收數據輸入時發生阻塞 只有等到程序獲得數據後才能繼續運行 隨著Internet的迅猛發展 這種狀況越來越不能讓人們忍受 如果網路接收數據阻塞 後台程序就處於等待狀態而不繼續任何操作 而這種阻塞是經常會碰到的 此時CPU資源被白白的閑置起來 如果在後台程序中能夠同時處理多個任務 該多好啊！應Internet技術而生的Java語言解決了這個問題 多線程程序是Java語言的一個很重要的特點 在一個Java程序中 我們可以同時並行運行多個相對獨立的線程 例如 我們如果創建一個線程來進行數據輸入輸出 而創建另一個線程在後台進行其它的數據處理 如果輸入輸出線程在接收數據時阻塞 而處理數據的線程仍然在運行 多線程程序設計大大提高了程序執行效率和處理能力
線程的創建
我們知道Java是面向對象的程序語言 用Java進行程序設計就是設計和使用類 Java為我們提供了線程類Thread來創建線程 創建線程與創建普通鬧梁的類的對象的操作是一樣的 而線程就是Thread類或其子類的實例對象 下面是一個創建啟動一個線程的語句
Thread thread =new Thread(); file://聲明困彎神一個對象實例 即創建一個線程
Thread run(); file://用Thread類中的run()方法啟動線程
從這個例子 我們可以通過Thread（）構造方法創建一個線程 並啟動該線程 事實上 啟動線程 也就是啟動線程的run（）方法 而Thread類中的run（）方法沒有任何操作語句 所以這個線程沒有任何操作 要使線程實現預定功能 必須定義自己的run（）方法 Java中通常有兩種方式定義run（）方法
通過定義一個Thread類的子類 在該子類中重寫run（）方法 Thread子類的實例對象就是一個線程 顯然 該線程汪虧有我們自己設計的線程體run（）方法 啟動線程就啟動了子類中重寫的run（）方法
通過Runnable介面 在該介面中定義run（）方法的介面 所謂介面跟類非常類似 主要用來實現特殊功能 如復雜關系的多重繼承功能 在此 我們定義一個實現Runnable（） 介面的類 在該類中定義自己的run（）方法 然後以該類的實例對象為參數調用Thread類的構造方法來創建一個線程
線程被實際創建後處於待命狀態 激活（啟動）線程就是啟動線程的run（）方法 這是通過調用線程的start（）方法來實現的
下面一個例子實踐了如何通過上述兩種方法創建線程並啟動它們
// 通過Thread類的子類創建的線程 class thread extends Thread { file://自定義線程的run()方法 public void run() { System out println( Thread is running… ); } } file://通過Runnable介面創建的另外一個線程 class thread implements Runnable { file://自定義線程的run()方法 public void run() { System out println( Thread is running… ); } } file://程序的主類 class Multi_Thread file://聲明主類 { plubic static void mail(String args[]) file://聲明主方法 { thread threadone=new thread (); file://用Thread類的子類創建線程 Thread threado=new Thread(new thread ()); file://用Runnable介面類的對象創建線程 threadone start(); threado start(); file://strat()方法啟動線程 } }
運行該程序就可以看出 線程threadone和threado交替佔用CPU 處於並行運行狀態 可以看出 啟動線程的run()方法是通過調用線程的start()方法來實現的(見上例中主類) 調用start()方法啟動線程的run()方法不同於一般的調用方法 調用一般方法時 必須等到一般方法執行完畢才能夠返回start()方法 而啟動線程的run()方法後 start()告訴系統該線程准備就緒可以啟動run()方法後 就返回start()方法執行調用start()方法語句下面的語句 這時run()方法可能還在運行 這樣 線程的啟動和運行並行進行 實現了多任務操作
線程的優先順序
對於多線程程序 每個線程的重要程度是不盡相同 如多個線程在等待獲得CPU時間時 往往我們需要優先順序高的線程優先搶佔到CPU時間得以執行 又如多個線程交替執行時 優先順序決定了級別高的線程得到CPU的次數多一些且時間多長一些 這樣 高優先順序的線程處理的任務效率就高一些
Java中線程的優先順序從低到高以整數 ~ 表示 共分為 級 設置優先順序是通過調用線程對象的setPriority()方法 如上例中 設置優先順序的語句為
thread threadone=new thread (); file://用Thread類的子類創建線程
Thread threado=new Thread(new thread ()); file://用Runnable介面類的對象創建線程
threadone setPriority( ); file://設置threadone的優先順序
threado setPriority( ); file://設置threado的優先順序
threadone start(); threado start(); file://strat()方法啟動線程
這樣 線程threadone將會優先於線程threado執行 並將佔有更多的CPU時間 該例中 優先順序設置放在線程啟動前 也可以在啟動後進行設置 以滿足不同的優先順序需求
線程的（同步）控制
一個Java程序的多線程之間可以共享數據 當線程以非同步方式訪問共享數據時 有時候是不安全的或者不和邏輯的 比如 同一時刻一個線程在讀取數據 另外一個線程在處理數據 當處理數據的線程沒有等到讀取數據的線程讀取完畢就去處理數據 必然得到錯誤的處理結果 這和我們前面提到的讀取數據和處理數據並行多任務並不矛盾 這兒指的是處理數據的線程不能處理當前還沒有讀取結束的數據 但是可以處理其它的數據
如果我們採用多線程同步控制機制 等到第一個線程讀取完數據 第二個線程才能處理該數據 就會避免錯誤 可見 線程同步是多線程編程的一個相當重要的技術
在講線程的同步控制前我們需要交代如下概念
用Java關鍵字synchonized同步對共享數據操作的方法
在一個對象中 用synchonized聲明的方法為同步方法 Java中有一個同步模型 監視器 負責管理線程對對象中的同步方法的訪問 它的原理是 賦予該對象唯一一把 鑰匙 當多個線程進入對象 只有取得該對象鑰匙的線程才可以訪問同步方法 其它線程在該對象中等待 直到該線程用wait（）方法放棄這把鑰匙 其它等待的線程搶占該鑰匙 搶佔到鑰匙的線程後才可得以執行 而沒有取得鑰匙的線程仍被阻塞在該對象中等待
file://聲明同步的一種方式 將方法聲明同步
class store {public synchonized void store_in(){… }public synchonized void store_out(){ … }}
利用wait（） notify（）及notifyAll（）方法發送消息實現線程間的相互聯系
Java程序中多個線程通過消息來實現互動聯系的 這幾種方法實現了線程間的消息發送 例如定義一個對象的synchonized 方法 同一時刻只能夠有一個線程訪問該對象中的同步方法 其它線程被阻塞 通常可以用notify（）或notifyAll（）方法喚醒其它一個或所有線程 而使用wait（）方法來使該線程處於阻塞狀態 等待其它的線程用notify（）喚醒
一個實際的例子就是生產和銷售 生產單元將產品生產出來放在倉庫中 銷售單元則從倉庫中提走產品 在這個過程中 銷售單元必須在倉庫中有產品時才能提貨 如果倉庫中沒有產品 則銷售單元必須等待
程序中 假如我們定義一個倉庫類store 該類的實例對象就相當於倉庫 在store類中定義兩個成員方法 store_in（） 用來模擬產品製造者往倉庫中添加產品 strore_out（）方法則用來模擬銷售者從倉庫中取走產品 然後定義兩個線程類 customer類 其中的run（）方法通過調用倉庫類中的store_out（）從倉庫中取走產品 模擬銷售者 另外一個線程類procer中的run（）方法通過調用倉庫類中的store_in（）方法向倉庫添加產品 模擬產品製造者 在主類中創建並啟動線程 實現向倉庫中添加產品或取走產品
如果倉庫類中的store_in（） 和store_out（）方法不聲明同步 這就是個一般的多線程 我們知道 一個程序中的多線程是交替執行的 運行也是無序的 這樣 就可能存在這樣的問題
倉庫中沒有產品了 銷售者還在不斷光顧 而且還不停的在 取 產品 這在現實中是不可思義的 在程序中就表現為負值 如果將倉庫類中的stroe_in（）和store_out（）方法聲明同步 如上例所示 就控制了同一時刻只能有一個線程訪問倉庫對象中的同步方法 即一個生產類線程訪問被聲明為同步的store_in（）方法時 其它線程將不能夠訪問對象中的store_out（）同步方法 當然也不能訪問store_in（）方法 必須等到該線程調用wait（）方法放棄鑰匙 其它線程才有機會訪問同步方法
lishixin/Article/program/Java/gj/201311/27301
『肆』 Java線程怎樣使用
多進程是指操作系統能同時運行多個任務（程序），多線程是指在同一程序中有多個順序流在執行。
在java中創建一個線程有兩種方法：
packagecom.thread;
publicclassThreadTest1{
publicstaticvoidmain(String[]args){
Runnable1r=newRunnable1();
//r.run();並不是線程開啟，而是簡單的方法調用
Threadt=newThread(r);//創建線程
//t.run();//如果該線程是使用獨立的Runnable運行對象構造的，則調用該Runnable對象的run方法；否則，該方法不執行任何操作並返回。
t.start();//線程開啟
for(inti=0;i<100;i++){
System.out.println("main:"+i);
}
}
}
{
publicvoidrun(){
for(inti=0;i<100;i++){
System.out.println("Thread-----:"+i);
}
}
}
『伍』 java怎麼創建一個線程
Java線程類也是一個object類,它的實例都繼承自java.lang.Thread或其子類。可以用如下方式用java中創建一個線程：
Treadthread=newThread();
執行該線程可以調用該線程的start()方法:
thread.start();
編寫線程運行時執行的代碼有兩種方式：一種是創建Thread子類的一個實例並重寫run方法，第二種是創建類的時候實現Runnable介面。接下來我們會具體講解這兩種方法：
創建Thread的子類
創建Thread子類的一個實例並重寫run方法，run方法會在調用start()方法之後被執行。例子如下：
{
publicvoidrun(){
System.out.println("MyThreadrunning");
}
}可以用如下方式創建並運行上述Thread子類
MyThreadmyThread=newMyThread();
myTread.start();
一旦線程啟動後start方法就會立即返回，而不會等待到run方法執行完畢才返回。就好像run方法是在另外一個cpu上執行一樣。當run方法執行後，將會列印出字元串MyThread running。
實現Runnable介面
第二種編寫線程執行代碼的方式是新建一個實現了java.lang.Runnable介面的類的實例，實例中的方法可以被線程調用。下面給出例子：
{
publicvoidrun(){
System.out.println("MyRunnablerunning");
}
}為了使線程能夠執行run()方法，需要在Thread類的構造函數中傳入MyRunnable的實例對象。示例如下：
Threadthread=newThread(newMyRunnable());
thread.start();
當線程運行時，它將會調用實現了Runnable介面的run方法。上例中將會列印出」MyRunnable running」。
『陸』 java有幾種實現線程的方式
有三種：
(1)繼承Thread類，重寫run函數
創建：class xx extends Thread{ public void run(){Thread.sleep(1000) //線程休眠1000毫秒，sleep使線程進入Block狀態，並釋放資源}}
開啟線程：對象.start() //啟動線程，run函數運行
(2)實現Runnable介面，重寫run函數
開啟線程：Thread t = new Thread(對象) //創建線程對象t.start()
(3)實現Callable介面，重寫call函數
Callable是類似於Runnable的介面，實現Callable介面的類和實現Runnable的類都是可被其它線程執行的任務。
『柒』 java線程類是什麼
線程，有時被稱為輕量級進程(Lightweight Process，LWP），是程序執行流的最小單元。一個標準的線程由線程ID，當前指令指針(PC），寄存器集合和堆棧組成。另外，線程是進程中的一個實體，是被系統獨立調度和分派的基本單位，線程自己不擁有系統資源，只擁有一點在運行中必不可少的資源，但它可與同屬一個進程的其它線程共享進程所擁有的全部資源。一個線程可以創建和撤消另一個線程，同一進程中的多個線程之間可以並發執行。由於線程之間的相互制約，致使線程在運行中呈現出間斷性。線程也有就緒、阻塞和運行三種基本狀態。每一個程序都至少有一個線程，那就是程序本身。
線程是程序中一個單一的順序控制流程。在單個程序中同時運行多個線程完成不同的工作，稱為多線程。
『捌』 Java多線程編程
作者 natrium 一 理解多線程多線程是這樣一種機制 它允許在程序中並發執行多個指令流 每個指令流都稱為一個線程 彼此間互相獨立 線程又稱為輕量級進程 它和進程一樣擁有獨立的執行控制 由操作系統負責調度 區別在於線程沒有獨立的存儲空間 而是和所屬進程中的其它線程共享一個存儲空間 這使得線程間的通信遠較進程簡單 多個線程的執行是並發的 也就是在邏輯上 同時 而不管是否是物理上的 同時 如果系統只有一個CPU 那麼真正的 同時 是不可能的 但是由於CPU的速度非常快 用戶感覺不到其中的區別 因此我們也不用關心它 只需要設想各個線程是同時執行即可 多線程和傳統的單線程在程序設計上最大的區別在於 由於各個線程的控制流彼此獨立 使得各個線程之間的代碼是亂序執行的 由此帶來的線程調度 同步等問題 將在以後探討 二 在Java中實現多線程我們不妨設想 為了創建一個新的線程 我們需要做些什麼？很顯然 我們必須指明這個線程所要執行的代碼 而這就是在Java中實現多線程我們所需要做的一切！真是神奇！Java是如何做到這一點的？通過類！作為一個完全面向對象的語言 Java提供了類 java lang Thread 來方便多線程編程 這個類提供了大量的方法來方便我們控制自己的各個線程 我們以後的討論都將圍繞這個類進行 那麼如何提供給 Java 我們要線程執行的代碼呢？讓我們來看一看 Thread 類 Thread 類最重要的方法是 run() 它為Thread 類的方法 start() 所調用 提供我們的線程所要執行的代碼 為了指定我們自己的代碼 只需要覆蓋它！方法一 繼承 Thread 類 覆蓋方法 run() 我們在創建的 Thread 類的子類中重寫 run() 加入線程所要執行的代碼即可 下面是一個例子 public class MyThread extends Thread {int count= number;public MyThread(int num) {number = num;System out println( 創建線程 + number);}public void run() {while(true) {System out println( 線程 + number + :計數 + count);if(++count== ) return;}}public static void main(String args[]) {for(int i = ; i < 5; i++) new MyThread(i+1).start();}}這種方法簡單明了，符合大家的習慣，但是，它也有一個很大的缺點，那就是如果我們的類已經從一個類繼承（如小程序必須繼承自 Applet 類），則無法再繼承 Thread 類，這時如果我們又不想建立一個新的類，應該怎麼辦呢？我們不妨來探索一種新的方法：我們不創建 Thread 類的子類，而是直接使用它，那麼我們只能將我們的方法作為參數傳遞給 Thread 類的實例，有點類似回調函數。.WINgWIT.但是 Java 沒有指針，我們只能傳遞一個包含這個方法的類的實例。那麼如何限制這個類必須包含這一方法呢？當然是使用介面！（雖然抽象類也可滿足，但是需要繼承，而我們之所以要採用這種新方法，不就是為了避免繼承帶來的限制嗎？）Java 提供了介面 java.lang.Runnable 來支持這種方法。方法二：實現 Runnable 介面Runnable 介面只有一個方法 run()，我們聲明自己的類實現 Runnable 介面並提供這一方法，將我們的線程代碼寫入其中，就完成了這一部分的任務。但是 Runnable 介面並沒有任何對線程的支持，我們還必須創建 Thread 類的實例，這一點通過 Thread 類的構造函數public Thread(Runnable target);來實現。下面是一個例子：public class MyThread implements Runnable {int count= 1, number;public MyThread(int num) {number = num;System.out.println("創建線程 " + number);}public void run() {while(true) {System.out.println("線程 " + number + ":計數 " + count);if(++count== 6) return;} }public static void main(String args[]) {for(int i = 0; i < 5; i++) new Thread(new MyThread(i+1)).start();}}嚴格地說，創建 Thread 子類的實例也是可行的，但是必須注意的是，該子類必須沒有覆蓋 Thread 類的 run 方法，否則該線程執行的將是子類的 run 方法，而不是我們用以實現Runnable 介面的類的 run 方法，對此大家不妨試驗一下。使用 Runnable 介面來實現多線程使得我們能夠在一個類中包容所有的代碼，有利於封裝，它的缺點在於，我們只能使用一套代碼，若想創建多個線程並使各個線程執行不同的代碼，則仍必須額外創建類，如果這樣的話，在大多數情況下也許還不如直接用多個類分別繼承 Thread 來得緊湊。綜上所述，兩種方法各有千秋，大家可以靈活運用。下面讓我們一起來研究一下多線程使用中的一些問題。三：線程的四種狀態1. 新狀態：線程已被創建但尚未執行（start() 尚未被調用）。2. 可執行狀態：線程可以執行，雖然不一定正在執行。CPU 時間隨時可能被分配給該線程，從而使得它執行。3. 死亡狀態：正常情況下 run() 返回使得線程死亡。調用 stop()或 destroy() 亦有同樣效果，但是不被推薦，前者會產生異常，後者是強制終止，不會釋放鎖。4. 阻塞狀態：線程不會被分配 CPU 時間，無法執行。四：線程的優先順序 線程的優先順序代表該線程的重要程度，當有多個線程同時處於可執行狀態並等待獲得 CPU 時間時，線程調度系統根據各個線程的優先順序來決定給誰分配 CPU 時間，優先順序高的線程有更大的機會獲得 CPU 時間，優先順序低的線程也不是沒有機會，只是機會要小一些罷了。你可以調用 Thread 類的方法 getPriority() 和 setPriority()來存取線程的優先順序，線程的優先順序界於1(MIN_PRIORITY)和10(MAX_PRIORITY)之間，預設是5(NORM_PRIORITY)。五：線程的同步由於同一進程的多個線程共享同一片存儲空間，在帶來方便的同時，也帶來了訪問沖突這個嚴重的問題。Java語言提供了專門機制以解決這種沖突，有效避免了同一個數據對象被多個線程同時訪問。由於我們可以通過 private 關鍵字來保證數據對象只能被方法訪問，所以我們只需針對方法提出一套機制，這套機制就是 synchronized 關鍵字，它包括兩種用法：synchronized 方法和 synchronized 塊。1. synchronized 方法：通過在方法聲明中加入 synchronized關鍵字來聲明 synchronized 方法。如：public synchronized void accessVal(int newVal);synchronized 方法控制對類成員變數的訪問：每個類實例對應一把鎖，每個 synchronized 方法都必須獲得調用該方法的類實例的鎖方能執行，否則所屬線程阻塞，方法一旦執行，就獨占該鎖，直到從該方法返回時才將鎖釋放，此後被阻塞的線程方能獲得該鎖，重新進入可執行狀態。這種機制確保了同一時刻對於每一個類實例，其所有聲明為 synchronized 的成員函數中至多隻有一個處於可執行狀態（因為至多隻有一個能夠獲得該類實例對應的鎖），從而有效避免了類成員變數的訪問沖突（只要所有可能訪問類成員變數的方法均被聲明為 synchronized）。在 Java 中，不光是類實例，每一個類也對應一把鎖，這樣我們也可將類的靜態成員函數聲明為 synchronized ，以控制其對類的靜態成員變數的訪問。synchronized 方法的缺陷：若將一個大的方法聲明為synchronized 將會大大影響效率，典型地，若將線程類的方法 run() 聲明為 synchronized ，由於在線程的整個生命期內它一直在運行，因此將導致它對本類任何 synchronized 方法的調用都永遠不會成功。當然我們可以通過將訪問類成員變數的代碼放到專門的方法中，將其聲明為 synchronized ，並在主方法中調用來解決這一問題，但是 Java 為我們提供了更好的解決辦法，那就是 synchronized 塊。2. synchronized 塊：通過 synchronized關鍵字來聲明synchronized 塊。語法如下： synchronized(syncObject) {//允許訪問控制的代碼}synchronized 塊是這樣一個代碼塊，其中的代碼必須獲得對象 syncObject （如前所述，可以是類實例或類）的鎖方能執行，具體機制同前所述。由於可以針對任意代碼塊，且可任意指定上鎖的對象，故靈活性較高。六：線程的阻塞為了解決對共享存儲區的訪問沖突，Java 引入了同步機制，現在讓我們來考察多個線程對共享資源的訪問，顯然同步機制已經不夠了，因為在任意時刻所要求的資源不一定已經准備好了被訪問，反過來，同一時刻准備好了的資源也可能不止一個。為了解決這種情況下的訪問控制問題，Java 引入了對阻塞機制的支持。阻塞指的是暫停一個線程的執行以等待某個條件發生（如某資源就緒），學過操作系統的同學對它一定已經很熟悉了。Java 提供了大量方法來支持阻塞，下面讓我們逐一分析。1. sleep() 方法：sleep() 允許 指定以毫秒為單位的一段時間作為參數，它使得線程在指定的時間內進入阻塞狀態，不能得到CPU 時間，指定的時間一過，線程重新進入可執行狀態。典型地，sleep() 被用在等待某個資源就緒的情形：測試發現條件不滿足後，讓線程阻塞一段時間後重新測試，直到條件滿足為止。2. suspend() 和 resume() 方法：兩個方法配套使用，suspend()使得線程進入阻塞狀態，並且不會自動恢復，必須其對應的resume() 被調用，才能使得線程重新進入可執行狀態。典型地，suspend() 和 resume() 被用在等待另一個線程產生的結果的情形：測試發現結果還沒有產生後，讓線程阻塞，另一個線程產生了結果後 lishixin/Article/program/Java/gj/201311/27622
『玖』 java有幾種實現線程的方式
有三種：
(1)繼承Thread類，重寫run函數
創建：class xx extends Thread{ public void run(){Thread.sleep(1000)//線程休眠1000毫秒，sleep使線程進入Block狀態，並釋放資源}}
開啟線程：對象.start()//啟動線程，run函數運行
(2)實現Runnable介面，重寫run函數
開啟線程：Thread t = new Thread(對象)//創建線程對象t.start()
(3)實現Callable介面，重寫call函數
Callable是類似於Runnable的介面，實現Callable介面的類和實現Runnable的類都是可被其它線程執行的任務。