線程建立的三種方式及比較

• • 繼承Thread類建立線程類
  • 實作Runnable接口建立線程
  • 使用Callable和Future建立線程
  • 實作接口和繼承類來建立線程的比較

1.繼承Thread類建立線程類

通過繼承Thread類建立并啟動多線程的步驟如下：

• 定義Thread類的子類，并重寫該類的run()方法，該run()方法的方法體就代表了線程需要完成的任務。
• 建立Thread子類的執行個體，及建立了線程對象。
• 調用線程對象的start()方法來啟動該線程。

public class Firsthread extends Thread{

    private int i;

    public void run(){
        for(;i<;i++){
            System.out.println(getName() + " " + i);
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        for(int i=;i<;i++){
            System.out.println(Thread.currentThread().getName() + " " + i);
            if( i == ){
                new Firsthread().start();
                new Firsthread().start();
            }
        }
    }
}
           

2.實作Runnable接口建立線程

實作Runnable接口建立線程并啟動多線程的步驟如下：

• 定義Runnable接口的實作類，并重寫該接口的run()方法，該run()方法的方法體同樣是該線程的線程執行體
• 建立Runnable實作類的執行個體，并以此執行個體為Thread的target來建立Thread對象，該Thread對象才是真正的線程對象

public class SecondThread implements Runnable{  
    private int i;

    public void run(){
        for(;i<;i++){
            //想擷取目前線程，隻能用Thread.currentThread()
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        for(int i=;i<;i++){
            System.out.println(Thread.currentThread().getName() + " " + i);
            if( i == ){
                SecondThread st = new SecondThread();
                //通過new Thread(target,name)方法建立線程
                new Thread(st,"新線程1").start();
                new Thread(st,"新線程2").start();
            }
        }
    }
}
           

3.使用Callable和Future建立線程

從Java 5開始，Java提供了Callable接口，該接口提供了call()方法作為線程執行體，call()方法可以有傳回值，call()方法可以聲明抛出異常。

Java 5提供了Future接口來代表Callable接口裡的call()方法的傳回值，并為Future接口提供一個FutureTask實作類，該實作類實作了Future接口，并實作了Runnable接口，即可作為Thread類的target。

public interface Future<V> {
    /**
     *試圖取消Future關聯的Callable任務
     */
    boolean cancel(boolean mayInterruptIfRunning);

    /**
     *如果在Callable任務正常完成前被取消，則傳回true
     */
    boolean isCancelled();

    /**
     *如果Callable任務已完成，則傳回true
     */
    boolean isDone();

    /**
     *傳回Callable任務裡call()方法的傳回值。
     *調用該方法将導緻程式阻塞，必須等到子線程結束後才會得到傳回值
     */
    V get() throws InterruptedException, ExecutionException;

    /**
     *傳回Callable任務裡call()方法的傳回值。
     *該方法讓程式最多阻塞timeout和unit指定的時間。
     *如果經過指定時間後Callable任務依然沒有傳回值，将會抛出TimoutException異常
     */
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}
           

建立并啟動有傳回值的線程的步驟如下：

• 建立Callable接口的實習類，并實作call()方法，該call()方法将作為線程執行體，且該call()方法有傳回值，再建立Callable實習類的執行個體。從Java 8開始，可以直接使用Lambda表達式建立Callable對象。
• 使用FutureTask類包裝Callable對象，該FutureTask對象封裝了該Callable對象的call()方法的傳回值。
• 使用FutureTask對象作為Thread對象的target建立并啟動新線程。
• 調用FutureTask對象的get()方法獲得子線程執行結束後的傳回值。

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class ThirdThread {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ThirdThread rt = new ThirdThread();

        //先使用Lambda表達式建立Callable<Integer>對象
        //再用FutureTask來包裝Callable對象
        FutureTask<Integer> task = new FutureTask<Integer>((Callable<Integer>)()->{
            int i = ;
            for(;i<;i++){
                System.out.println(Thread.currentThread().getName() + "的循環變量i的值：" + i);
            }
            return i;
        });

        for(int i=;i<;i++){
            System.out.println(Thread.currentThread().getName() + "的循環變量i的值：" + i);
            if(i == ){
                new Thread(task,"有傳回值的線程").start();
            }
        }
        try{
            System.out.println("子線程的傳回值: " + task.get());
        }
        catch(Exception e){
            e.printStackTrace();
        }
    }

}
           

實作接口和繼承類來建立線程的比較

采用實作Runnable、Callable接口的方式建立多線程的優缺點：

• 線程類隻是實作了接口，還可以繼承其他類
• 在這種情況下，多個線程可以共享同一個target對象，是以非常适合多個相同線程來處理同一份資源的情況，進而可以将CPU，代碼和資料分開，形成清晰的模型，較好的展現了面向對象的思想。
• 程式設計稍稍複雜，如果需要通路目前線程，則需要使用Thread.currentThread()

采用繼承Thread類的方式建立多線程的優缺點：

• 線程類已經繼承了Thread類，是以不能再繼承其他父類
• 編寫簡單，如果需要通路目前線程，不需要使用Thread.currentThread()，直接使用this

是以，一般推薦使用實作Runnable、Callable接口的方式建立多線程。