JUC（6）Callable与Runnable的区别、Future

原创

悬浮海分海 2022-07-11 17:29:00 ©著作权

文章标签 Callable Runnable future java 线程池 文章分类 Spark 大数据

©著作权归作者所有：来自51CTO博客作者悬浮海分海的原创作品，请联系作者获取转载授权，否则将追究法律责任

文章目录

一、Runnable
二、Callable(简单)
三、FutureTask（很有用）
四、Callable 接口和 Runnable接口的区别
五、异步回调 Future

5.1没有返回值的 runAsync() 异步回调
5.2有返回值的supplyAsync() 异步回调
5.3与Callable在线程池中的使用

一、Runnable

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

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

二、Callable(简单)

JUC（6）Callable与Runnable的区别、Future_java

创建线程的第三种方式
Callable ：可以有返回值；可以抛出异常；与Runnable中的方法不同，run()/call()
两个细节：有缓存、结果需要等待（会阻塞）
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;
}

Callable的使用

package com.wlw.callable;

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

public class CallableTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //Callable怎么放入到Thread里面呢？
        //对于Thread运行，只能传入Runnable类型的参数； 我们这是Callable 怎么办呢？
        //在Runnable里面有一个叫做FutureTask的实现类，FutureTask中可以接受Callable参数；
        //这样我们就可以先把Callable 放入到FutureTask中， 再把FutureTask 放入到Thread就可以了。
        //new Thread(new Runnable()).start();
        //new Thread(new FutureTask<>( Callable)).start();

        MyThread myThread = new MyThread();
        FutureTask futureTask = new FutureTask(myThread);
        new Thread(futureTask,"A").start();
        new Thread(futureTask,"B").start(); //这两个线程只输出了一个call，结果会被缓存，效率高

        Integer o = (Integer)futureTask.get(); 
         //这个get方法可能会被阻塞，如果在cal1方法中是一个耗时的方法，所以一般情况我们会把这个放在最后，或者使用异步通信

        System.out.println(o);
    }
}

class MyThread implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        System.out.println("call");
        return 1024;
    }
}

三、FutureTask（很有用）

FutureTask是一个RunnableFuture

public class FutureTask<V> implements RunnableFuture<V>

RunnableFuture实现了Runnbale又实现了Futrue这两个接口

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，由构造函数注入依赖。

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

总结：

FutureTask实现Runnable，所以能通过Thread包装执行，
FutureTask实现Runnable，所以能通过提交给ExcecuteService来执行，注：ExecuteService：创建线程池实例对象，其中有submit（Runnable）、submit（Callable）方法
还可以直接通过get()函数获取执行结果，该函数会阻塞，直到结果返回。
因此FutureTask是Future也是Runnable，又是包装了的Callable( 如果是Runnable最终也会被转换为Callable )。

四、Callable 接口和 Runnable接口的区别

Callable规定的方法是call()，而Runnable规定的方法是run()
Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。
call()方法可抛出异常，而run()方法是不能抛出异常的。
运行Callable任务可拿到一个Future对象， Future表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。
通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。
Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。

五、异步回调 Future

Future 设计的初衷：对将来的某个事件结果进行建模！
异步回调，我们可以想到 ajax（前端 --> 发送ajax异步请求给后端）
看一下jdk文档

JUC（6）Callable与Runnable的区别、Future_java_02

5.1没有返回值的 runAsync() 异步回调

package com.wlw.future;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

/**
 *异步调用: CompletableFuture
 *   异步执行.
 *   成功回调
 *   失败回调
 */

public class Demo01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //发送一个请求，采用的是无返回值的 runAsync() 异步回调
        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(()->{
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"==>runAsync 无返回值的异步回调 void");
        });

        System.out.println("1111111111111111");

        completableFuture.get(); //阻塞 的获取等待结果 ，它会等待发送请求之后的执行结果,但是并不影响其他代码的执行
    }
}

5.2有返回值的supplyAsync() 异步回调

package com.wlw.future;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class Demo02 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //有返回值的supplyAsync() 异步回调
        //分为成功和失败的回调
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread().getName()+"==>supplyAsync 有返回值的异步回调 Integer");
            int a = 10/0;
            return 1024;
        });

        System.out.println(completableFuture.whenComplete((t, u) -> {
            System.out.println("t==>" + t);  //成功回调，得到的正常的返回结果
            System.out.println("u==>" + u); //  抛出异常的 输出的错误信息  u==>java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
        }).exceptionally((e) -> {
            System.out.println(e.getMessage());
            return 233; //获取到错误的返回结果
        }).get());
    }
}

5.3与Callable在线程池中的使用

Callable对象是可以直接传给线程池的（不需要转换成FutureTask）
线程池.submit （线程池的提交）有返回值，为future : 表示将要执行完任务的结果，就是call()的返回值
Future：表示将要完成任务的结果
方法：V get() 以阻塞形式等待Future中的异步处理结果（call()的返回值）
需求：使用两个线程，并发计算1-50，51-100的和，再进行汇总

package com.wlw.thread.threaddemo02;

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

/**
 * Future接口的使用
 * 需求：使用两个线程，并发计算1~50，51~100的和，再进行汇总
 */
public class FutureDemo {
    public static void main(String[] args) throws Exception{
        
        //1.创建线程池
        ExecutorService es = Executors.newFixedThreadPool(2);
        
        //2.提交任务
        Future<Integer> future1 = es.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println(Thread.currentThread().getName()+"计算开始");
                int sum = 0;
                for (int i = 0; i <= 50; i++) {
                    sum += i;
                }
                System.out.println("1~50 计算完毕");
                return sum;
            }
        });
        Future<Integer> future2 = es.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println(Thread.currentThread().getName()+"计算开始");
                int sum = 0;
                for (int i = 51; i <= 100; i++) {
                    sum += i;
                }
                System.out.println("51~100 计算完毕");
                return sum;
            }
        });

        //3.获取结果(get() 方法要等call() 方法执行完毕，才能返回)
        System.out.println(future1.get()+future2.get());

        //4.关闭线程池
        es.shutdown();
    }
}
/*
执行结果：
pool-1-thread-1计算开始
pool-1-thread-2计算开始
51~100 计算完毕
1~50 计算完毕
5050
*/

上一篇：一、【SpringCloud】微服务与分布式架构

下一篇：Redis【第一篇总结】

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯