Java線程—-Runnable和Callable的區別和聯系

Java 提供了三種創建線程的方法

1.繼承Thread接口

public class Thread2Thread {
    public static void main(String[] args) {
        new MyThread1().start();
        new Thread(new MyThread1(), "線程2").start();
    }
}

/**
 * 通過繼承Thread類
 */
class MyThread1 extends Thread {
    /**
     * 重寫run方法
     */
    @Override
    public void run() {
        // TODO Auto-generated method stub
        super.run();
    }
}

2.實現Runnable接口

package com.testthread.demo4;

import java.util.concurrent.ExecutorService;

import static java.util.concurrent.Executors.*;

public class Thread2Runnable {

    public static void main(String[] args) {

        //case1:通過實現Runnable接口，來實現run方法的具體邏輯
        new Thread(new MyThread2(), "線程1").start();
        //case2:匿名內部類
        new Thread(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub

            }
        }, "線程2").start();

        //其實case1和case2的本質是一樣的
        
        //case3:作為線程任務提交給線程池，通過線程池維護的工作者線程來執行。
        ExecutorService executor = newCachedThreadPool();
        MyThread2 myThread2 = new MyThread2();
        executor.execute(myThread2);
        executor.shutdown();
    }
}

/**
 * 實現Runnable接口的線程類
 */
class MyThread2 implements Runnable {

    /**
     * 重寫run方法
     */
    @Override
    public void run() {
        // TODO Auto-generated method stub
    }
}

3.通過Callable和Future創建線程

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

public class Thread2Callable {
    public static void main(String[] args) {
        //創建 Callable 實現類的實例
        MyCallable myCallable = new MyCallable();
        //使用 FutureTask 類來包裝 Callable 對象，該 FutureTask 對象封裝了該 Callable 對象的 call() 方法的返回值
        FutureTask<String> futureTask = new FutureTask<String>(myCallable);
        String res = null;
        try {
            //使用 FutureTask 對象作為 Thread 對象的 target 創建並啟動新線程
            //沒這句，下句代碼獲取不到結果，會一直等待執行結果
            new Thread(futureTask,"線程1").start();
            //調用 FutureTask 對象的 get() 方法來獲得子線程執行結束后的返回值
            res = futureTask.get();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(res);
    }
}
/**
 * 創建 Callable 接口的實現類，並實現 call() 方法
 */
class MyCallable implements Callable<String> {

    /**
     * 該 call() 方法將作為線程執行體，並且有返回值
     */
    @Override
    public String call() throws Exception {
        return "success";
    }
}

 

Runnable和Callable的區別和聯系

閱讀目錄

• 接口定義
• 相同點
• 不同點
• 示例
• 關系圖

接口定義

　　Runnable　　

其中Runnable應該是我們最熟悉的接口，它只有一個run()函數，用於將耗時操作寫在其中，該函數沒有返回值。然后使用某個線程去執行該runnable即可實現多線程，Thread類在調用start()函數后就是執行的是Runnable的run()函數。

Runnable的聲明如下 :

public interface Runnable {
    /*
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

　　#Callable

Callable與Runnable的功能大致相似，Callable中有一個call()函數，但是call()函數有返回值，而Runnable的run()函數不能將結果返回給客戶程序。

Callable的聲明如下 :

public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

 

　　#Future

Executor就是Runnable和Callable的調度容器，Future就是對於具體的Runnable或者Callable任務的執行結果進行
取消、查詢是否完成、獲取結果、設置結果操作。get方法會阻塞，直到任務返回結果(Future簡介)。

Future聲明如下 :

public interface Future<V> {
 
    /**
     * Attempts to cancel execution of this task.  This attempt will
     * fail if the task has already completed, has already been cancelled,
     * or could not be cancelled for some other reason. If successful,
     * and this task has not started when <tt>cancel</tt> is called,
     * this task should never run.  If the task has already started,
     * then the <tt>mayInterruptIfRunning</tt> parameter determines
     * whether the thread executing this task should be interrupted in
     * an attempt to stop the task.
     */
    boolean cancel(boolean mayInterruptIfRunning);
 
    /**
     * Returns <tt>true</tt> if this task was cancelled before it completed
     * normally.
     */
    boolean isCancelled();
 
    /**
     * Returns <tt>true</tt> if this task completed.
     *
     */
    boolean isDone();
 
    /**
     * Waits if necessary for the computation to complete, and then
     * retrieves its result.
     *
     * @return the computed result
     */
    V get() throws InterruptedException, ExecutionException;
 
    /**
     * Waits if necessary for at most the given time for the computation
     * to complete, and then retrieves its result, if available.
     *
     * @param timeout the maximum time to wait
     * @param unit the time unit of the timeout argument
     * @return the computed result
     */
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

#FutureTask（很有用）

　　FutureTask是一個RunnableFuture<V>　　

public class FutureTask<V> implements RunnableFuture<V>

 RunnableFuture實現了Runnbale又實現了Futrue<V>這兩個接口

public interface RunnableFuture<V> extends Runnable, Future<V> {
    /**
     * Sets this Future to the result of its computation
     * unless it has been cancelled.
     */
    void run();
}

另外FutureTaslk還可以包裝Runnable和Callable<V>， 由構造函數注入依賴。

    public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }
 
    public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
    }

上面代碼塊可以看出：Runnable注入會被Executors.callable()函數轉換為Callable類型，即FutureTask最終都是執行Callable類型的任務。

該適配函數的實現如下 ：

    public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<T>(task, result);
    }

RunnableAdapter適配器

    /**
     * A callable that runs given task and returns given result
     */
    static final class RunnableAdapter<T> implements Callable<T> {
        final Runnable task;
        final T result;
        RunnableAdapter(Runnable task, T result) {
            this.task = task;
            this.result = result;
        }
        public T call() {
            task.run();
            return result;
        }
    }

FutureTask實現Runnable，所以能通過Thread包裝執行，

FutureTask實現Runnable，所以能通過提交給ExcecuteService來執行

注：ExecuteService：創建線程池實例對象，其中有submit（Runnable）、submit（Callable）方法

ExecturService：https://blog.csdn.net/suifeng3051/article/details/49443835

還可以直接通過get()函數獲取執行結果，該函數會阻塞，直到結果返回。

因此FutureTask是Future也是Runnable，又是包裝了的Callable( 如果是Runnable最終也會被轉換為Callable )。

 

相同點

都是接口
都可以編寫多線程程序
都采用Thread.start()啟動線程

 不同點

 Callable規定的方法是call()，而Runnable規定的方法是run(). 
 Callable的任務執行后可返回值，而Runnable的任務是不能返回值的。  
  call()方法可拋出異常，而run()方法是不能拋出異常的。--run()方法異常只能在內部消化，不能往上繼續拋
  運行Callable任務可拿到一個Future對象， Future表示異步計算的結果。 
  它提供了檢查計算是否完成的方法，以等待計算的完成，並檢索計算的結果。 
  通過Future對象可了解任務執行情況，可取消任務的執行，還可獲取任務執行的結果。 
 Callable是類似於Runnable的接口，實現Callable接口的類和實現Runnable的類都是可被其它線程執行的任務。 
注：Callalbe接口支持返回執行結果，需要調用FutureTask.get()得到，此方法會阻塞主進程的繼續往下執行，如果不調用不會阻塞。

 示例：

package com.xzf.callable;
 
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
 
public class RunnableFutureTask {
    static ExecutorService executorService = Executors.newSingleThreadExecutor();    //創建一個單線程執行器
    public static void main(String[] args) {
        runnableDemo();    
        futureDemo();
    }
    /**
     * new Thread(Runnable arg0).start(); 用Thread()方法開啟一個新線程
     * runnable, 無返回值
     */
    static void runnableDemo() {
        new Thread(new Runnable() {                
            public void run() {
                System.out.println("runnable demo:" + fibc(20));    //有值
            }
            
        }).start();
    }
    /**
     * Runnable實現的是void run()方法，無返回值
     * Callable實現的是 V call()方法，並且可以返回執行結果
     * Runnable可以提交給Thread,在包裝下直接啟動一個線程來執行
     * Callable一般都是提交給ExecuteService來執行
     */ 
     
    static void futureDemo() {
        try {
            Future<?> result1 = executorService.submit(new Runnable() {
                public void run() {
                    fibc(20);
                }
            });
            System.out.println("future result from runnable:"+result1.get());    //run()無返回值所以為空，result1.get()方法會阻塞
            Future<Integer> result2 = executorService.submit(new Callable<Integer>()     {
                public Integer call() throws Exception {
                    return fibc(20);    
                }
            });
            System.out.println("future result from callable:"+result2.get());    //call()有返回值，result2.get()方法會阻塞
            FutureTask<Integer> result3 = new FutureTask<Integer>(new Callable<Integer>() {
                public Integer call() throws Exception {
                    return fibc(20);
                }
            });
            executorService.submit(result3);    
            System.out.println("future result from FutureTask:" + result3.get());    //call()有返回值，result3.get()方法會阻塞
            
            /*因為FutureTask實現了Runnable，因此它既可以通過Thread包裝來直接執行，也可以提交給ExecuteService來執行*/
            FutureTask<Integer> result4 = new FutureTask<Integer>(new Runnable() {
                public void run() {
                    fibc(20);
                }
            },fibc(20));    
            executorService.submit(result4);
            System.out.println("future result from executeService FutureTask :" + result4.get());    //call()有返回值，result3.get()方法會阻塞
            //這里解釋一下什么FutureTask實現了Runnable結果不為null，這就用到FutureTask對Runnable的包裝，所以Runnable注入會被Executors.callable()函數轉換成Callable類型
 
            FutureTask<Integer> result5 = new FutureTask<Integer>(new Runnable() {
                public void run() {
                    fibc(20);
                }
            },fibc(20));
            new Thread(result5).start();
            System.out.println("future result from Thread FutureTask :" + result5.get());    //call()有返回值，result5.get()方法會阻塞
            
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            executorService.shutdown();
        }
    }
    static int fibc(int num) {
        if (num==0) {
            return 0;
        }
        if (num==1) {
            return 1;
        }
        return fibc(num-1) + fibc(num-2);
    }
}

運行結果：

runnable demo:6765
future result from runnable:null
future result from callable:6765
future result from FutureTask:6765
future result from executeService FutureTask :6765
future result from Thread FutureTask :6765

package com.testthread.test;

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

public class Test implements Callable<Object> {
    private String taskNum;

    Test(String taskNum) {
        this.taskNum = taskNum;
    }

    public static void main(String[] args) {
        System.out.println("----程序開始運行----");
        Date date1 = new Date();
        int taskSize = 5; // 創建一個線程池
        ExecutorService pool = Executors.newFixedThreadPool(taskSize); // 創建多個有返回值的任務
        List<Future> list = new ArrayList<Future>();
        try {
            for (int i = 0; i < taskSize; i++) {
                Callable c = new Test(i + " "); // 執行任務並獲取Future對象
                Future f = pool.submit(c);
                list.add(f);
            }
            // 獲取所有並發任務的運行結果
            for (Future f : list) {
                // 從Future對象上獲取任務的返回值，並輸出到控制台
                System.out.println(">>>" + f.get().toString());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } finally {// 關閉線程池
            pool.shutdown();
        }
        Date date2 = new Date();
        System.out.println("----程序結束運行----，程序運行時間【" + (date2.getTime() - date1.getTime()) + "毫秒】");
    }

    @Override
    public Object call() throws Exception {
        System.out.println(">>>" + taskNum + "任務啟動");
        Date dateTmp1 = new Date();
        Thread.sleep(1000);
        Date dateTmp2 = new Date();
        long time = dateTmp2.getTime() - dateTmp1.getTime();
        System.out.println(">>>" + taskNum + "任務終止");
        return taskNum + "任務返回運行結果,當前任務時間【" + time + "毫秒】";
    }
}

----程序開始運行----
>>>1 任務啟動
>>>0 任務啟動
>>>3 任務啟動
>>>2 任務啟動
>>>4 任務啟動
>>>1 任務終止
>>>3 任務終止
>>>0 任務終止
>>>0 任務返回運行結果,當前任務時間【1029毫秒】
>>>2 任務終止
>>>1 任務返回運行結果,當前任務時間【1029毫秒】
>>>2 任務返回運行結果,當前任務時間【1030毫秒】
>>>3 任務返回運行結果,當前任務時間【1030毫秒】
>>>4 任務終止
>>>4 任務返回運行結果,當前任務時間【1030毫秒】
----程序結束運行----，程序運行時間【1146毫秒】

package com.testthread.test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.FutureTask;

import static java.util.concurrent.Executors.newFixedThreadPool;

public class Test2 {

    public static void main(String[] args) {
        Map<String, Object> resultMap = new HashMap<>();
        int count = 10;
        ExecutorService executorService = newFixedThreadPool(10);
        long start = System.currentTimeMillis();
        try {
            List<FutureTask> list = new ArrayList();
            for (int i = 0; i < count; i++) {
                FutureTask<Map<String, Object>> result = new FutureTask<Map<String, Object>>(myCall(i + ""));
                executorService.submit(result);
                list.add(result);
            }
            for (int i = 0; i < count; i++) {
                Map<String, Object> resultMapShow = (Map<String, Object>) list.get(i).get();
                System.out.println("resultMapShow = " + resultMapShow);
                Map<String, Object> body = (Map<String, Object>) resultMapShow.get("body");
                resultMap.put("aa" + i, body.get("aa"));
            }
            System.out.println("====>took:" + (System.currentTimeMillis() - start));

        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } finally {
            executorService.shutdown();
        }
        System.out.println("resultMap = " + resultMap);
        System.out.println("==>took:" + (System.currentTimeMillis() - start));
    }


    public static Callable<Map<String, Object>> myCall(String taskId) {
        Callable<Map<String, Object>> callable = new Callable<Map<String, Object>>() {
            @Override
            public Map<String, Object> call() throws Exception {
                return queryMethod(taskId);
            }
        };
        return callable;
    }

    private static Map<String, Object> queryMethod(String taskId) {
        try {
            System.out.println(" ==>任務啟動" + taskId);
            long startI = System.currentTimeMillis();
            Thread.sleep(500);
//            System.out.println("   sleep:500ms");
            System.out.println(" ==>任務終止" + taskId + " 任務時間:" + (System.currentTimeMillis() - startI));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Map<String, Object> resultMap = new HashMap<>();
        Map<String, Object> head = new HashMap<>();
        head.put("retFlag", "0000");
        head.put("retMsg", "成功");
        Map<String, Object> body = new HashMap<>();
        body.put("aa", "11");
        resultMap.put("head", head);
        resultMap.put("body", body);
        return resultMap;
    }
}

 ==>任務啟動0
 ==>任務啟動1
 ==>任務啟動2
 ==>任務啟動3
 ==>任務啟動4
 ==>任務啟動5
 ==>任務啟動6
 ==>任務啟動7
 ==>任務啟動8
 ==>任務啟動9
 ==>任務終止0 任務時間:501
resultMapShow = {head={retMsg=成功, retFlag=0000}, body={aa=11}}
 ==>任務終止4 任務時間:502
 ==>任務終止3 任務時間:502
 ==>任務終止2 任務時間:502
 ==>任務終止1 任務時間:502
resultMapShow = {head={retMsg=成功, retFlag=0000}, body={aa=11}}
resultMapShow = {head={retMsg=成功, retFlag=0000}, body={aa=11}}
resultMapShow = {head={retMsg=成功, retFlag=0000}, body={aa=11}}
resultMapShow = {head={retMsg=成功, retFlag=0000}, body={aa=11}}
 ==>任務終止6 任務時間:502
 ==>任務終止5 任務時間:502
resultMapShow = {head={retMsg=成功, retFlag=0000}, body={aa=11}}
resultMapShow = {head={retMsg=成功, retFlag=0000}, body={aa=11}}
 ==>任務終止8 任務時間:501
 ==>任務終止7 任務時間:501
resultMapShow = {head={retMsg=成功, retFlag=0000}, body={aa=11}}
resultMapShow = {head={retMsg=成功, retFlag=0000}, body={aa=11}}
 ==>任務終止9 任務時間:501
resultMapShow = {head={retMsg=成功, retFlag=0000}, body={aa=11}}
====>took:525
resultMap = {aa1=11, aa0=11, aa3=11, aa2=11, aa5=11, aa4=11, aa7=11, aa6=11, aa9=11, aa8=11}
==>took:526

 

 

關系圖：

下面是關系圖，望有助理解

 

 

 轉自：https://blog.csdn.net/sinat_39634657/article/details/81456810

https://blog.csdn.net/u012894692/article/details/80215140

https://blog.csdn.net/rexueqingchun/article/details/79025882