Java并發(fā)系列：Thread、Runnable、Callable、Future和FutureTask

在Java的世界里，異步操作一般使用Thread，本篇來講講Thread的有返回值和無返回值的多線程Api。

無返回值的Thread創(chuàng)建

  1. 繼承Thread，復(fù)寫run方法，多線程執(zhí)行時回調(diào)Thread的run()方法進(jìn)行執(zhí)行任務(wù)。
/**
 * 使用Thread，復(fù)寫run方法進(jìn)行任務(wù)執(zhí)行
 */
private static void runThread() {
    Thread thread = new Thread() {
        @Override
        public void run() {
            super.run();
            System.out.println("我在" + Thread.currentThread().getName() + "中執(zhí)行...");
        }
    };
    thread.start();
}

//輸出
我在Thread-0中執(zhí)行...
  1. 使用Runnable，和Thread組合執(zhí)行。Thread還有一個有參構(gòu)造傳入Runnable，任務(wù)執(zhí)行則在Runnable的run()方法中執(zhí)行。
/**
 * 使用Runnable構(gòu)建Thread對象
 */
private static void runThreadByRunnable() {
    Thread thread = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("我是Runnable中的任務(wù)");
            System.out.println("我在" + Thread.currentThread().getName() + "中執(zhí)行...");
        }
    });
    thread.start();
}

//輸出
我是Runnable中的任務(wù)
我在Thread-0中執(zhí)行...

3.需要注意的是，Thread啟動線程不能調(diào)用run()，必須調(diào)用start()，否則執(zhí)行任務(wù)的線程為當(dāng)前線程，而不是新起一個線程去執(zhí)行。

private static void runThreadByRunnable() {
    Thread thread = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("我是Runnable中的任務(wù)");
            System.out.println("我在" + Thread.currentThread().getName() + "中執(zhí)行...");
        }
    });
    //錯誤示范，Thread啟動線程不能調(diào)用run()，必須調(diào)用start()，否則執(zhí)行任務(wù)的線程為當(dāng)前線程，而不是新起一個線程去執(zhí)行。
    thread.run();
}

//輸出
我是Runnable中的任務(wù)
我在main中執(zhí)行...

有返回值Thread

使用Runnable和Thread，是沒有返回值的，當(dāng)我們需要獲取到結(jié)果后，繼續(xù)執(zhí)行時，就有點(diǎn)尷尬了而在JDK1.5時，提供了**Callable、Future和FutureTask**，作為多線程Api的補(bǔ)充。一起來看下吧

  1. 首先，Callable，是一個帶返回值的接口，對比Runnable來對比。
//有返回值，Callable
public interface Callable<V> {
    V call() throws Exception;
}

//無返回值，Runnable
public interface Runnable {
    public abstract void run();
}
  1. 而Future，為有結(jié)果操作對象的操作接口。
public interface Future<V> {
    //取消執(zhí)行
    boolean cancel(boolean mayInterruptIfRunning);

    //是否已取消
    boolean isCancelled();

    //是否已結(jié)束
    boolean isDone();

    //獲取返回值，阻塞操作，如果還未執(zhí)行完，則會以一個死循環(huán)進(jìn)行循環(huán)檢查，直到生成了結(jié)果，結(jié)束阻塞并返回結(jié)果
    V get() throws InterruptedException, ExecutionException;

    //get重載，設(shè)置一個超時時間，如果指定時間后還未返回結(jié)果，拋出TimeoutException異常
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}
  1. FutureTask，既然Callable是返回值任務(wù)回調(diào)接口，F(xiàn)uture為操作接口，感覺還少點(diǎn)東西，啥呢？缺一個Future的實(shí)現(xiàn)類，不然操作的狀態(tài)誰來維護(hù)呢？(cancel、done)。
//FutureTask實(shí)現(xiàn)了RunnableFuture接口，來瞅瞅~
public class FutureTask<V> implements RunnableFuture<V> {
}

//RunnableFuture接口，繼承自Runnable和Future
public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

//創(chuàng)建FutureTask。要在子線程執(zhí)行，就需要Thread環(huán)境，而Thread類的構(gòu)造方法只能傳一個Runnable，剛好RunnableFuture實(shí)現(xiàn)了Runnable，所以Thread的構(gòu)造就能傳入FutureTask對象。
Callable<String> callable = new Callable<String>() {
    @Override
    public String call() throws Exception {
        System.out.println("我在" + Thread.currentThread().getName() + "中執(zhí)行...");
        return "我是結(jié)果";
    }
};
FutureTask<String> futureTask = new FutureTask<>(callable);
//將任務(wù)交給線程執(zhí)行
Thread thread = new Thread(futureTask);
thread.start();
  1. 獲取返回值結(jié)果，因?yàn)镕utureTask實(shí)現(xiàn)了Future接口，所以它有g(shù)et()方法。我們調(diào)用get方法獲取結(jié)果。
//...省略上面代碼
FutureTask<String> futureTask = new FutureTask<>(callable);
//將任務(wù)交給線程執(zhí)行
Thread thread = new Thread(futureTask);
thread.start();
String result = futureTask.get();
//獲取結(jié)果
System.out.println("我是FutureTask+Callable中執(zhí)行的任務(wù)，結(jié)果為: " + result);
  1. 最終代碼
/**
 * 帶返回值的任務(wù)
 */
private static void runThreadByCallable() {
    Callable<String> callable = new Callable<String>() {
        @Override
        public String call() throws Exception {
            System.out.println("我在" + Thread.currentThread().getName() + "中執(zhí)行...");
            return "我是結(jié)果";
        }
    };
    FutureTask<String> futureTask = new FutureTask<>(callable);
    try {
        //將任務(wù)交給線程執(zhí)行
        Thread thread = new Thread(futureTask);
        thread.start();
        //futureTask.cancel(true);
        //如果取消或結(jié)束了，就不往下走了
        if (futureTask.isCancelled()) {
            System.out.println("任務(wù)被取消了");
            return;
        }
        if (futureTask.isDone()) {
            System.out.println("任務(wù)完成了");
            return;
        }
        String result = futureTask.get();
        System.out.println("我是FutureTask+Callable中執(zhí)行的任務(wù)，結(jié)果為: " + result);
        if (futureTask.isDone()) {
            System.out.println("我完成任務(wù)啦...");
        }
    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }
}

//輸出
我在Thread-0中執(zhí)行...
我是FutureTask+Callable中執(zhí)行的任務(wù)，結(jié)果為: 我是結(jié)果
我完成任務(wù)啦...

使用線程池

頻繁創(chuàng)建線程和銷毀線程，十分消耗資源。那么有沒有復(fù)用線程，執(zhí)行任務(wù)的Api呢？有，那就是線程池線程池這里不細(xì)講哈

  • 不帶返回值的結(jié)果。在線程池中執(zhí)行~
/**
 * 不帶返回值的任務(wù)在線程池中執(zhí)行
 */
private static void runThreadByExecutorService(Runnable runnable) {
    ExecutorService executor = Executors.newCachedThreadPool();
    executor.execute(runnable);
}

//輸出
我在pool-1-thread-1中執(zhí)行...
  • 帶返回值的結(jié)果，這里使用Executors創(chuàng)建一個線程池，通過executor.submit()提交Callable，返回一個Future接口對象。哎？怎么沒有FutureTask出現(xiàn)？我們來看submit()方法。原來submit()將Callable包裝為RunnableFuture，再返回啦~所以不需要new FutureTask()喔~而返回的Future接口，就是RunnableFuture。
//提交任務(wù)
public <T> Future<T> submit(Callable<T> task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<T> ftask = newTaskFor(task);
    execute(ftask);
    return ftask;
}

//將Callable包裝為RunnableFuture
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
    return new FutureTask<T>(callable);
}
  • 最終代碼~
/**
 * 帶返回值任務(wù)在線程池中執(zhí)行
 */
private static void runThreadByExecutorService() {
    //創(chuàng)建線程池
    ExecutorService executor = Executors.newCachedThreadPool();
    //提交任務(wù)
    Future<String> future = executor.submit(new Callable<String>() {
        @Override
        public String call() throws Exception {
            System.out.println("我在" + Thread.currentThread().getName() + "中執(zhí)行...");
            return "我是結(jié)果";
        }
    });
    executor.shutdown();
    try {
         //獲取結(jié)果
        String result = future.get();
        System.out.println("帶返回值的任務(wù)-結(jié)果為: " + result);
    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }
}

//輸出
我在pool-1-thread-1中執(zhí)行...
帶返回值的任務(wù)-結(jié)果為: 我是結(jié)果

總結(jié)

  1. 需要在子線程中執(zhí)行任務(wù)，并返回返回值時，最好使用JDK提供的Callable、Future和FutureTask來實(shí)現(xiàn)~
  2. 頻繁使用線程，需要使用線程池。
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。