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();

     }

 }

通过继承Thread类

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

     }

 }

实现Runnable接口

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";

     }

 }

通过Callable和Future创建线程

Runnable和Callable的区别和联系

阅读目录

接口定义

　　Runnable　　

其中Runnable应该是我们最熟悉的接口，它只有一个run()函数，用于将耗时操作写在其中，该函数没有返回值。然后使用某个线程去执行该runnable即可实现多线程，Thread类在调用start()函数后就是执行的是Runnable的run()函数。

Runnable的声明如下 :

 public interface Runnable {

     /*

      * @see     java.lang.Thread#run()

      */

     public abstract void run();

 }

Runnable

　　#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;

 }

Future

#FutureTask（很有用）

　　FutureTask是一个RunnableFuture<V>　　

 public class FutureTask<V> implements RunnableFuture<V>

FutureTask

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();

 }

RunnableFuture

另外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

     }

FutureTask（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);

     }

callable

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;

         }

     }

RunnableAdapter

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);

     }

 }

示例1

运行结果：

 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

运行结果1

 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 + "毫秒】";

     }

 }

示例2

 ----程序开始运行----

 >>>1 任务启动

 >>>0 任务启动

 >>>3 任务启动

 >>>2 任务启动

 >>>4 任务启动

 >>>1 任务终止

 >>>3 任务终止

 >>>0 任务终止

 >>>0 任务返回运行结果,当前任务时间【1029毫秒】

 >>>2 任务终止

 >>>1 任务返回运行结果,当前任务时间【1029毫秒】

 >>>2 任务返回运行结果,当前任务时间【1030毫秒】

 >>>3 任务返回运行结果,当前任务时间【1030毫秒】

 >>>4 任务终止

 >>>4 任务返回运行结果,当前任务时间【1030毫秒】

 ----程序结束运行----，程序运行时间【1146毫秒】

示例2结果

 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;

     }

 }

示例3

  ==>任务启动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

示例3结果

关系图：

下面是关系图，望有助理解

转自：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