java建立執行緒的四種方法（轉）

阿新 • • 發佈：2018-11-08

java中建立執行緒的四種方法以及區別

Java使用Thread類代表執行緒，所有的執行緒物件都必須是Thread類或其子類的例項。Java可以用四種方式來建立執行緒，如下所示：

1）繼承Thread類建立執行緒

2）實現Runnable介面建立執行緒

3）使用Callable和Future建立執行緒

4）使用執行緒池例如用Executor框架

下面讓我們分別來看看這四種建立執行緒的方法。

------------------------繼承Thread類建立執行緒---------------------

通過繼承Thread類來建立並啟動多執行緒的一般步驟如下

1】d定義Thread類的子類，並重寫該類的run()方法，該方法的方法體就是執行緒需要完成的任務，run()方法也稱為執行緒執行體。

2】建立Thread子類的例項，也就是建立了執行緒物件

3】啟動執行緒，即呼叫執行緒的start()方法

程式碼例項

public class MyThread extends Thread{//繼承Thread類

　　public void run(){

　　//重寫run方法

　　}

public class Main {

　　public static void main(String[] args){

　　　　new MyThread().start();//建立並啟動執行緒

　　}

------------------------實現Runnable介面建立執行緒---------------------

通過實現Runnable介面建立並啟動執行緒一般步驟如下：

1】定義Runnable介面的實現類，一樣要重寫run()方法，這個run（）方法和Thread中的run()方法一樣是執行緒的執行體

2】建立Runnable實現類的例項，並用這個例項作為Thread的target來建立Thread物件，這個Thread物件才是真正的執行緒物件

3】第三部依然是通過呼叫執行緒物件的start()方法來啟動執行緒

程式碼例項：

public class MyThread2 implements Runnable {//實現Runnable介面

　　public void run(){

　　//重寫run方法

　　}

public class Main {

　　public static void main(String[] args){

　　　　//建立並啟動執行緒

　　　　MyThread2 myThread=new MyThread2();

　　　　Thread thread=new Thread(myThread);

　　　　thread().start();

　　　　//或者 new Thread(new MyThread2()).start();

　　}

------------------------使用Callable和Future建立執行緒---------------------

和Runnable介面不一樣，Callable介面提供了一個call（）方法作為執行緒執行體，call()方法比run()方法功能要強大。

》call()方法可以有返回值

》call()方法可以宣告丟擲異常

Java5提供了Future介面來代表Callable接口裡call()方法的返回值，並且為Future介面提供了一個實現類FutureTask，這個實現類既實現了Future介面，還實現了Runnable介面，因此可以作為Thread類的target。在Future接口裡定義了幾個公共方法來控制它關聯的Callable任務。

>boolean cancel(boolean mayInterruptIfRunning)：檢視取消該Future裡面關聯的Callable任務

>V get()：返回Callable裡call（）方法的返回值，呼叫這個方法會導致程式阻塞，必須等到子執行緒結束後才會得到返回值

>V get(long timeout,TimeUnit unit)：返回Callable裡call（）方法的返回值，最多阻塞timeout時間，經過指定時間沒有返回丟擲TimeoutException

>boolean isDone()：若Callable任務完成，返回True

>boolean isCancelled()：如果在Callable任務正常完成前被取消，返回True

介紹了相關的概念之後，建立並啟動有返回值的執行緒的步驟如下：

1】建立Callable介面的實現類，並實現call()方法，然後建立該實現類的例項（從java8開始可以直接使用Lambda表示式建立Callable物件）。

2】使用FutureTask類來包裝Callable物件，該FutureTask物件封裝了Callable物件的call()方法的返回值

3】使用FutureTask物件作為Thread物件的target建立並啟動執行緒（因為FutureTask實現了Runnable介面）

4】呼叫FutureTask物件的get()方法來獲得子執行緒執行結束後的返回值

程式碼例項：

public class Main {

　　public static void main(String[] args){

　　　MyThread3 th=new MyThread3();

　　　//使用Lambda表示式建立Callable物件

　　 //使用FutureTask類來包裝Callable物件

　　　FutureTask<Integer> future=new FutureTask<Integer>(

　　　　(Callable<Integer>)()->{

　　　　　　return 5;

　　　　}

　　 );

　　　new Thread(task,"有返回值的執行緒").start();//實質上還是以Callable物件來建立並啟動執行緒

　　 try{

　　　　System.out.println("子執行緒的返回值："+future.get());//get()方法會阻塞，直到子執行緒執行結束才返回

　　 }catch(Exception e){

　　　　ex.printStackTrace();

　　　}

------------------------使用執行緒池例如用Executor框架---------------------

1.5後引入的Executor框架的最大優點是把任務的提交和執行解耦。要執行任務的人只需把Task描述清楚，然後提交即可。這個Task是怎麼被執行的，被誰執行的，什麼時候執行的，提交的人就不用關心了。具體點講，提交一個Callable物件給ExecutorService（如最常用的執行緒池ThreadPoolExecutor），將得到一個Future物件，呼叫Future物件的get方法等待執行結果就好了。Executor框架的內部使用了執行緒池機制，它在java.util.cocurrent 包下，通過該框架來控制執行緒的啟動、執行和關閉，可以簡化併發程式設計的操作。因此，在Java 5之後，通過Executor來啟動執行緒比使用Thread的start方法更好，除了更易管理，效率更好（用執行緒池實現，節約開銷）外，還有關鍵的一點：有助於避免this逃逸問題——如果我們在構造器中啟動一個執行緒，因為另一個任務可能會在構造器結束之前開始執行，此時可能會訪問到初始化了一半的物件用Executor在構造器中。

Executor框架包括：執行緒池，Executor，Executors，ExecutorService，CompletionService，Future，Callable等。

Executor介面中之定義了一個方法execute（Runnable command），該方法接收一個Runable例項，它用來執行一個任務，任務即一個實現了Runnable介面的類。ExecutorService介面繼承自Executor介面，它提供了更豐富的實現多執行緒的方法，比如，ExecutorService提供了關閉自己的方法，以及可為跟蹤一個或多個非同步任務執行狀況而生成 Future 的方法。可以呼叫ExecutorService的shutdown（）方法來平滑地關閉 ExecutorService，呼叫該方法後，將導致ExecutorService停止接受任何新的任務且等待已經提交的任務執行完成(已經提交的任務會分兩類：一類是已經在執行的，另一類是還沒有開始執行的)，當所有已經提交的任務執行完畢後將會關閉ExecutorService。因此我們一般用該介面來實現和管理多執行緒。

ExecutorService的生命週期包括三種狀態：執行、關閉、終止。建立後便進入執行狀態，當呼叫了shutdown（）方法時，便進入關閉狀態，此時意味著ExecutorService不再接受新的任務，但它還在執行已經提交了的任務，當素有已經提交了的任務執行完後，便到達終止狀態。如果不呼叫shutdown（）方法，ExecutorService會一直處在執行狀態，不斷接收新的任務，執行新的任務，伺服器端一般不需要關閉它，保持一直執行即可。

Executors提供了一系列工廠方法用於創先執行緒池，返回的執行緒池都實現了ExecutorService介面。

public static ExecutorService newFixedThreadPool(int nThreads)

建立固定數目執行緒的執行緒池。

public static ExecutorService newCachedThreadPool()

建立一個可快取的執行緒池，呼叫execute將重用以前構造的執行緒（如果執行緒可用）。如果現有執行緒沒有可用的，則建立一個新線程並新增到池中。終止並從快取中移除那些已有 60 秒鐘未被使用的執行緒。

public static ExecutorService newSingleThreadExecutor()

建立一個單執行緒化的Executor。

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

建立一個支援定時及週期性的任務執行的執行緒池，多數情況下可用來替代Timer類。

這四種方法都是用的Executors中的ThreadFactory建立的執行緒，下面就以上四個方法做個比較

newCachedThreadPool()
-快取型池子，先檢視池中有沒有以前建立的執行緒，如果有，就 reuse.如果沒有，就建一個新的執行緒加入池中
-快取型池子通常用於執行一些生存期很短的非同步型任務
因此在一些面向連線的daemon型SERVER中用得不多。但對於生存期短的非同步任務，它是Executor的首選。
-能reuse的執行緒，必須是timeout IDLE內的池中執行緒，預設 timeout是60s,超過這個IDLE時長，執行緒例項將被終止及移出池。
注意，放入CachedThreadPool的執行緒不必擔心其結束，超過TIMEOUT不活動，其會自動被終止。

newFixedThreadPool(int)
-newFixedThreadPool與cacheThreadPool差不多，也是能reuse就用，但不能隨時建新的執行緒
-其獨特之處:任意時間點，最多隻能有固定數目的活動執行緒存在，此時如果有新的執行緒要建立，只能放在另外的佇列中等待，直到當前的執行緒中某個執行緒終止直接被移出池子
-和cacheThreadPool不同，FixedThreadPool沒有IDLE機制（可能也有，但既然文件沒提，肯定非常長，類似依賴上層的TCP或UDP IDLE機制之類的），所以FixedThreadPool多數針對一些很穩定很固定的正規併發執行緒，多用於伺服器
-從方法的原始碼看，cache池和fixed 池呼叫的是同一個底層池，只不過引數不同:
fixed池執行緒數固定，並且是0秒IDLE（無IDLE）
cache池執行緒數支援0-Integer.MAX_VALUE(顯然完全沒考慮主機的資源承受能力），60秒IDLE

newScheduledThreadPool(int)
-排程型執行緒池
-這個池子裡的執行緒可以按schedule依次delay執行，或週期執行

SingleThreadExecutor()
-單例執行緒，任意時間池中只能有一個執行緒
-用的是和cache池和fixed池相同的底層池，但執行緒數目是1-1,0秒IDLE（無IDLE）

一般來說，CachedTheadPool在程式執行過程中通常會建立與所需數量相同的執行緒，然後在它回收舊執行緒時停止建立新執行緒，因此它是合理的Executor的首選，只有當這種方式會引發問題時（比如需要大量長時間面向連線的執行緒時），才需要考慮用FixedThreadPool。（該段話摘自《Thinking in Java》第四版）

Executor執行Runnable任務
通過Executors的以上四個靜態工廠方法獲得 ExecutorService例項，而後呼叫該例項的execute（Runnable command）方法即可。一旦Runnable任務傳遞到execute（）方法，該方法便會自動在一個執行緒上

[java] view pl

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestCachedThreadPool{
public static void main(String[] args){
ExecutorService executorService = Executors.newCachedThreadPool();
// ExecutorService executorService = Executors.newFixedThreadPool(5);
// ExecutorService executorService = Executors.newSingleThreadExecutor();
for (int i = 0; i < 5; i++){
executorService.execute(new TestRunnable());
System.out.println("************* a" + i + " *************");
}
executorService.shutdown();
}
}

class TestRunnable implements Runnable{
public void run(){
System.out.println(Thread.currentThread().getName() + "執行緒被呼叫了。");
}
}

某次執行後的結果如下：

從結果中可以看出，pool-1-thread-1和pool-1-thread-2均被呼叫了兩次，這是隨機的，execute會首先線上程池中選擇一個已有空閒執行緒來執行任務，如果執行緒池中沒有空閒執行緒，它便會建立一個新的執行緒來執行任務。

Executor執行Callable任務
在Java 5之後，任務分兩類：一類是實現了Runnable介面的類，一類是實現了Callable介面的類。兩者都可以被ExecutorService執行，但是Runnable任務沒有返回值，而Callable任務有返回值。並且Callable的call()方法只能通過ExecutorService的submit(Callable<T> task) 方法來執行，並且返回一個 <T>Future<T>，是表示任務等待完成的 Future。

Callable介面類似於Runnable，兩者都是為那些其例項可能被另一個執行緒執行的類設計的。但是 Runnable 不會返回結果，並且無法丟擲經過檢查的異常而Callable又返回結果，而且當獲取返回結果時可能會丟擲異常。Callable中的call()方法類似Runnable的run()方法，區別同樣是有返回值，後者沒有。

當將一個Callable的物件傳遞給ExecutorService的submit方法，則該call方法自動在一個執行緒上執行，並且會返回執行結果Future物件。同樣，將Runnable的物件傳遞給ExecutorService的submit方法，則該run方法自動在一個執行緒上執行，並且會返回執行結果Future物件，但是在該Future物件上呼叫get方法，將返回null。

下面給出一個Executor執行Callable任務的示例程式碼：

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class CallableDemo{
public static void main(String[] args){
ExecutorService executorService = Executors.newCachedThreadPool();
List<Future<String>> resultList = new ArrayList<Future<String>>();

//建立10個任務並執行
for (int i = 0; i < 10; i++){
//使用ExecutorService執行Callable型別的任務，並將結果儲存在future變數中
Future<String> future = executorService.submit(new TaskWithResult(i));
//將任務執行結果儲存到List中
resultList.add(future);
}

//遍歷任務的結果
for (Future<String> fs : resultList){
try{
while(!fs.isDone);//Future返回如果沒有完成，則一直迴圈等待，直到Future返回完成
System.out.println(fs.get()); //列印各個執行緒（任務）執行的結果
}catch(InterruptedException e){
e.printStackTrace();
}catch(ExecutionException e){
e.printStackTrace();
}finally{
//啟動一次順序關閉，執行以前提交的任務，但不接受新任務
executorService.shutdown();
}
}
}
}

class TaskWithResult implements Callable<String>{
private int id;

public TaskWithResult(int id){
this.id = id;
}

/**
* 任務的具體過程，一旦任務傳給ExecutorService的submit方法，
* 則該方法自動在一個執行緒上執行
*/
public String call() throws Exception {
System.out.println("call()方法被自動呼叫！！！ " + Thread.currentThread().getName());
//該返回結果將被Future的get方法得到
return "call()方法被自動呼叫，任務返回的結果是：" + id + " " + Thread.currentThread().getName();
}
}

程式碼：

某次執行結果如下：

從結果中可以同樣可以看出，submit也是首先選擇空閒執行緒來執行任務，如果沒有，才會建立新的執行緒來執行任務。另外，需要注意：如果Future的返回尚未完成，則get（）方法會阻塞等待，直到Future完成返回，可以通過呼叫isDone（）方法判斷Future是否完成了返回。

自定義執行緒池
自定義執行緒池，可以用ThreadPoolExecutor類建立，它有多個構造方法來建立執行緒池，用該類很容易實現自定義的執行緒池，這裡先貼上示例程式：

] view plai

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolTest{
public static void main(String[] args){
//建立等待佇列
BlockingQueue<Runnable> bqueue = new ArrayBlockingQueue<Runnable>(20);
//建立執行緒池，池中儲存的執行緒數為3，允許的最大執行緒數為5
ThreadPoolExecutor pool = new ThreadPoolExecutor(3,5,50,TimeUnit.MILLISECONDS,bqueue);
//建立七個任務
Runnable t1 = new MyThread();
Runnable t2 = new MyThread();
Runnable t3 = new MyThread();
Runnable t4 = new MyThread();
Runnable t5 = new MyThread();
Runnable t6 = new MyThread();
Runnable t7 = new MyThread();
//每個任務會在一個執行緒上執行
pool.execute(t1);
pool.execute(t2);
pool.execute(t3);
pool.execute(t4);
pool.execute(t5);
pool.execute(t6);
pool.execute(t7);
//關閉執行緒池
pool.shutdown();
}
}

class MyThread implements Runnable{
@Override
public void run(){
System.out.println(Thread.currentThread().getName() + "正在執行。。。");
try{
Thread.sleep(100);
}catch(InterruptedException e){
e.printStackTrace();
}
}
}

執行結果如下：

從結果中可以看出，七個任務是線上程池的三個執行緒上執行的。這裡簡要說明下用到的ThreadPoolExecuror類的構造方法中各個引數的含義。

public ThreadPoolExecutor (int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,BlockingQueue<Runnable> workQueue)

corePoolSize：執行緒池中所儲存的執行緒數，包括空閒執行緒。

maximumPoolSize：池中允許的最大執行緒數。

keepAliveTime：當執行緒數大於核心數時，該引數為所有的任務終止前，多餘的空閒執行緒等待新任務的最長時間。

unit：等待時間的單位。

workQueue：任務執行前儲存任務的佇列，僅儲存由execute方法提交的Runnable任務。

--------------------------------------四種建立執行緒方法對比--------------------------------------

實現Runnable和實現Callable介面的方式基本相同，不過是後者執行call()方法有返回值，後者執行緒執行體run()方法無返回值，因此可以把這兩種方式歸為一種這種方式與繼承Thread類的方法之間的差別如下：

1、執行緒只是實現Runnable或實現Callable介面，還可以繼承其他類。

2、這種方式下，多個執行緒可以共享一個target物件，非常適合多執行緒處理同一份資源的情形。

3、但是程式設計稍微複雜，如果需要訪問當前執行緒，必須呼叫Thread.currentThread()方法。

4、繼承Thread類的執行緒類不能再繼承其他父類（Java單繼承決定）。

5、前三種的執行緒如果建立關閉頻繁會消耗系統資源影響效能，而使用執行緒池可以不用執行緒的時候放回執行緒池，用的時候再從執行緒池取，專案開發中主要使用執行緒池

注：在前三種中一般推薦採用實現介面的方式來建立多執行緒
---------------------
作者：願好
來源：CSDN
原文：https://blog.csdn.net/m0_37840000/article/details/79756932
版權宣告：本文為博主原創文章，轉載請附上博文連結！

java建立執行緒的四種方法（轉）

java中建立執行緒的四種方法以及區別

java建立執行緒的四種方法（轉）

詳解Java解析XML的四種方法（轉載）

js 時間轉換毫秒的四種方法（轉）

跨執行緒使用使用者介面的四種方法（BackgroundThreadUpdateUI）

JAVA中執行緒同步的方法（7種）彙總

Java建立執行緒安全的方法

Java建立物件的四種方法

說說 Java 的執行緒本地化物件容器（ThreadLocal）

執行shell指令碼的四種方式（轉）

Java多執行緒之基礎篇（二）

Java多執行緒之基礎篇（一）

Java多執行緒程式設計學習總結（二）

Java 多執行緒程式設計學習總結（一）

java多執行緒之併發集合（CopyOnWriteArrayList）

java多執行緒之併發集合（BlockingQueue）

Java併發——執行緒安全的集合（二）

java多執行緒-專題-聊聊併發（二）Java SE1.6中的Synchronized

交換兩個變數的值，不借助第三個變數的四種方法（學習）

java多執行緒之同步鎖（Lock）

java中從鍵盤輸入的三種方法（轉）

java建立執行緒的四種方法（轉）

java中建立執行緒的四種方法以及區別

相關推薦