JDK多线程基础(7)：有返回的线程Callable接口以及 Future 模式

最新推荐文章于 2022-05-27 20:32:20 发布
最新推荐文章于 2022-05-27 20:32:20 发布
阅读量472 收藏 3
点赞数
分类专栏： 多线程 文章标签： Future  callable
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012228718/article/details/89283051
版权

文章目录

Callable 接口

Runnable 与 Callable

  1. 两者都是自定义 Task 可以实现的接口，区别在于 Callable 有返回值，且在线程执行过程中可以抛出异常
  2. 重写 各自的方法不同：Runnable.run()方法，Callable.call() 方法
public interface Runnable {
    public abstract void run();
}

public interface Callable<V> {
    V call() throws Exception; // 有返回值，可以抛出异常
}

JDK 的 Future 实现

  1. Future 模式
  • 一段程序提交了一个请求，期望得到一个答复，但是如果这个请求的处理是漫长的。传统的单线程，调用函数是同步的
  • Future 模式下，调用函数是异步的，而原先等待返回的时间，在主调用函数中，可以处理其他事务
  1. JDK 对于Future专门做了封装,主要是 Callable、Future、FutureTask

image

Future 模式

Future 接口

  1. boolean cancel(boolean mayInterruptIfRunning)：取消任务
  2. boolean isCancelled()：是否已经取消
  3. boolean isDone()：是否已经完成
  4. V get()：获取返回结果
  5. V get(long timeout, TimeUnit unit)：获取返回结果，可以设置超时时间

FutureTask 类

  1. 同时实现 Runnable、Future 接口
  2. 所以它既可以作为 Runnable 被线程执行，又可以作为 Future 得到Callable的返回值

ExecutorService 执行一个 Callable任务

<T> Future<T> submit(Callable<T> task);
<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);

Future 使用

实现 Callable 接口的自定义任务

class InCallableTask implements Callable<String> {
    @Override
    public String call() throws Exception {
        Thread.sleep(1000L);
        return "Hello SAM !! " + Thread.currentThread().getName();
    }
}

class InCallableTaskLongTime implements Callable<String> {
    @Override
    public String call() throws Exception {
        Thread.sleep(10000L);
        return "Hello SAM, Long Time Task : " + Thread.currentThread().getName();
    }
}
执行一个任务
  1. 一般用法，提交 Callable，使用 Future 接收
void test1() throws ExecutionException, InterruptedException {
    ExecutorService executor = Executors.newFixedThreadPool(1);
    // 提交一个 Callable
    Future<String> future = executor.submit(new InCallableTask());

    System.out.println(future.isDone());

    // 会一直阻塞, 直到任务完成，结果返回
    System.out.println(future.get());
}
  1. 使用 FutureTask 实现
void test2() throws ExecutionException, InterruptedException {
    // Callable 任务使用 FutureTask 封装
    FutureTask<String> future = new FutureTask<>(new InCallableTask());
    ExecutorService executor = Executors.newFixedThreadPool(1);
    // 提交 FutureTask , 因为FutureTask 实现了 Runnable, Future 接口
    executor.submit(future);

    // 会一直阻塞, 直到任务完成，结果返回
    System.out.println("返回的数据： " + future.get());

    executor.shutdown();
}
执行多个任务
  1. 一般用法：多次提交，任务谁先完成就先返回
void test3() throws Exception {
    ExecutorService executor = Executors.newFixedThreadPool(1);

    // 一般使用需要构建多个 FutureTask 对象
    FutureTask<String> future = new FutureTask<>(new InCallableTask());
    FutureTask<String> futureLongTime = new FutureTask<>(new InCallableTaskLongTime());

    // 提交两个任务
    executor.submit(future);
    executor.submit(futureLongTime);

    System.out.println("干其他事情去吧..........");

    System.out.println(future.get());
    System.out.println(futureLongTime.get());

    executor.shutdown();
}
  1. invokeAll、invokeAny 方法实现
  • invokeAll：任务都完成后一起返回，会等待最慢的那个任务完成后一起返回
  • invokeAny：返回最先完成的那个任务，未执行的任务都会被取消
void test4() throws ExecutionException, InterruptedException {
    ExecutorService executor = Executors.newFixedThreadPool(1);

    List<Callable<String>> list = new ArrayList<>(2);
    list.add(new InCallableTask());
    list.add(new InCallableTaskLongTime());

    // 需要所有的任务完成后才返回
    // 两个任务都完成后一起返回，会等待最慢的那个任务完成后一起返回
    List<Future<String>> futures = executor.invokeAll(list);
    for (Future<String> future : futures) {
        System.out.println(future.get());
    }

    // 返回最先完成的那个任务，未执行的任务都会被取消
    String result = executor.invokeAny(list);
    System.out.println(result);
}
  1. 使用 ExecutorCompletionService 提交一组任务，先完成的先返回
void test5() throws Exception {
    ExecutorService executor = Executors.newFixedThreadPool(1);
    // 创建 ExecutorCompletionService 类，内部使用 LinkedBlockingQueue 存放 Future，可以手动指定任务个数
    ExecutorCompletionService<String> ecs = new ExecutorCompletionService<>(executor);

    // 任务列表
    ArrayList<Callable<String>> tasks = Lists.newArrayList(new InCallableTask(), new InCallableTaskLongTime());

    List<Future<String>> futures = new ArrayList<>();

    // 提交一组任务
    for (Callable<String> callable : tasks) {
        Future<String> future = ecs.submit(callable);
        // 这边可以
        futures.add(future);
    }

    // 获取任务结果: 内部使用 BlockingQueue 存放 Future, 先完成的先返回
    for (int i = 0; i < tasks.size(); i++) {
        System.out.println(ecs.take().get());
    }

    // 这边应该在 finally 中处理
    for (Future<String> future : futures) {
        future.cancel(true);
    }

    executor.shutdown();
}

Guava 的实现

使用 ListenableFuture 提交任务

  1. ListenableFuture 方法可以添加回调、监控、异常捕获等
  2. MoreExecutors新增了很多有用的方法，如 关闭线程池
  3. 回调函数 addCallback 不会阻塞
public void test1() throws ExecutionException, InterruptedException {

    // 自定义线程池名称，使用 ThreadFactory 的构造方法
    ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("guava-ListenableFuture-%s").build();
    ExecutorService executorService = Executors.newFixedThreadPool(10, threadFactory);

    // 将 ExecutorService 转为 ListeningExecutorService
    ListeningExecutorService service = MoreExecutors.listeningDecorator(executorService);
    // 提交任务
    ListenableFuture<String> listenableFuture = service.submit(new InCallableTask());

    // 可以注册一个回调, 在回调函数中对异步处理的结果进行处理
    // 这个方法与 JDK 中的 future.get() 不同，不会 callback() 函数不阻塞当前线程
    Futures.addCallback(listenableFuture, new FutureCallback<String>() {
        // we want this handler to run immediately after we push the big red button!
        @Override
        public void onSuccess(String result) {
            System.out.println("获取的结果 " + result);
        }

        @Override
        public void onFailure(Throwable thrown) {
            thrown.printStackTrace();
        }
    });

    // 上面任务的异常，不会影响主线程后续的执行
    System.out.println("这边会先执行？ main task done.....");

    MoreExecutors.shutdownAndAwaitTermination(service, 60, TimeUnit.SECONDS);
}

使用 FutureTask 提交任务

针对JDK 的 FutureTask 转换而来的, Guava 提供 ListenableFutureTask.create(Callable<V>) 和ListenableFutureTask.create(Runnable, V)

public void test2() {
    // 自定义线程池名称，使用 ThreadFactory 的构造方法
    ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("guava-ListenableFutureTask-%s").build();
    ThreadPoolExecutor executorService = new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(), threadFactory);

    // 将 ThreadPoolExecutor 转为 ListeningExecutorService
    ListeningExecutorService service = MoreExecutors.listeningDecorator(executorService);

    // 创建 ListenableFutureTask
    ListenableFutureTask<String> listenableFutureTask = ListenableFutureTask.create(new InCallableTask());
    // 提交任务
    service.submit(listenableFutureTask);

    Futures.addCallback(listenableFutureTask, new FutureCallback<String>() {
        @Override
        public void onSuccess(String result) {
            System.out.println("获取的结果： " + result);
        }

        @Override
        public void onFailure(Throwable thrown) {
            thrown.printStackTrace();
        }
    });

    System.out.println("这边会先执行？ main task done.....");

    MoreExecutors.shutdownAndAwaitTermination(service, 60, TimeUnit.SECONDS);
}

提交一组任务

  1. Futures.allAsList(futures)：如果一个任务发生异常, 这边会抛出异常
  2. Futures.successfulAsList：返回一个ListenableFuture ，该Future的结果包含所有成功的Future，按照原来的顺序，当其中之一Failed 或者 cancel，则用null替代
  3. 以上两个方法都是阻塞的
public void test3() throws ExecutionException, InterruptedException {
    // 自定义线程池名称，使用 ThreadFactory 的构造方法
    ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("guava-ListenableFutureTask-%s").build();
    ThreadPoolExecutor executorService = new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(), threadFactory);

    // 将 ThreadPoolExecutor 转为 ListeningExecutorService
    ListeningExecutorService service = MoreExecutors.listeningDecorator(executorService);


    // 任务列表
    ArrayList<Callable<String>> tasks = Lists.newArrayList(new InCallableTask(), new InCallableTaskLongTime());

    List<ListenableFuture<String>> futures = Lists.newArrayList();

    // 提交任务
    for (Callable<String> task : tasks) {
        futures.add(service.submit(task));
    }
    // 返回一个ListenableFuture ，该Future的结果包含所有成功的Future，按照原来的顺序，当其中之一Failed或者cancel，则用null替代
    ListenableFuture<List<String>> listListenableFuture = Futures.successfulAsList(futures);

    // 堵塞，直到所有任务完成，然后一起返回
    // [Hello SAM!!  guava-ListenableFutureTask-0, Hello SAM, long time task guava-ListenableFutureTask-0]
    // 如果一个任务发生异常: [null, Hello SAM, long time task guava-ListenableFutureTask-0]
    System.out.println(listListenableFuture.get());

    // allAsList与 successfulAsList的区别
    // 如果一个任务发生异常, 这边会抛出异常，
    ListenableFuture<List<String>> listListenableFuture1 = Futures.allAsList(futures);
    System.out.println(listListenableFuture1.get());

    System.out.println("这边不会先执行 main task done.....");

    // 一定要记得关闭
    MoreExecutors.shutdownAndAwaitTermination(service, 60, TimeUnit.SECONDS);
}

其他功能（具体见 Guava 文章）

  1. 增加异常捕获等
public void test4() throws ExecutionException, InterruptedException {
    // 自定义线程池名称，使用 ThreadFactory 的构造方法
    ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("guava-ListenableFutureTask-%s").build();
    ThreadPoolExecutor executorService = new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(), threadFactory);

    // 将 ThreadPoolExecutor 转为 ListeningExecutorService
    ListeningExecutorService service = MoreExecutors.listeningDecorator(executorService);

    final InCallableTask inCallableTask = new InCallableTask();
    ListenableFuture<String> listenableFuture = service.submit(inCallableTask);

    Futures.catching(listenableFuture, RuntimeException.class, new Function<RuntimeException, String>() {
        @Override
        public String apply(RuntimeException input) {
            // 这边可以做一些其他事情,，如重新调用，各种异常处理
            return "你好，异常被我吃了";
        }
    });

    Futures.catchingAsync(listenableFuture, RuntimeException.class, new AsyncFunction<RuntimeException, String>() {
        @Override
        public ListenableFuture<String> apply(RuntimeException input) throws Exception {
            return listenableFuture;
        }
    });

    System.out.println(listenableFuture.get());
}

参考

  1. 源码地址

Fork me on Gitee

Sam Sho
关注
专栏目录
Java多线程入门4-实现Callable接口创建线程
jinyangjie的博客
12-30 695
Callable接口类似于Runnable，但 Runnable不返回结果，也不能抛出被检查的异常。
JDK7多线程部分类（接口）关系图
11-03
JDK7多线程部分类（接口）关系图，根据官网得出
Java7 多线程
God_Of_Gun的博客
09-28 310
多线程 Java.Thread 目录 线程简介 线程实现（重点） 线程状态 线程同步（重点） 线程通信问题 高级主题 线程简介 任务、进程、线程、多线程 一个进程可以有多个线程，如视频中同时听声音、看视频、看弹幕等 Process与Thread 程序s是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念 进程则是执行程序的一次执行过程，是一个动态的概念。是系统组员分配的单位 一个进程包含了若干个线程。一个进程至少有一个线程，不然没有存在的意义。线程是cpu调度和执行的单位。 注意：很多
java多线程系类：JUC线程池：06之Callable和Future（转）
weixin_33817333的博客
01-06 86
概要 本章介绍线程池中的Callable和Future。Callable 和 Future 简介示例和源码分析(基于JDK1.7.0_40) 转载请注明出处：http://www.cnblogs.com/skywang12345/p/3544116.html   Callable 和 Future 简介 　　Callable 和 Future 是比较有趣的一对组合。当我们需要获取线程的执行结果时，...
多线程(七)JDK原生线程池
liwang2016384的博客
07-24 416
如同数据库连接一样，线程的创建、切换和销毁同样会耗费大量的系统资源。为了复用创建好的线程，减少频繁创建线程的次数，提高线程利用率可以引用线程池技术。使用线程池的优势有如下几点：         1、保持一定数量的线程，减少了线程频繁创建和销毁资源消耗。         2、使用线程的时候直接由线程池中取出线程，省去了创建线程的时间，侧面提高了系统的响应时间。         3、需要使用线程的时候...
Java高级程序员必备:高性能计数器及Striped64和LongAdder
qq_64513388的博客
11-26 526
基于JDK 7，我们如何实现一个多线程计数器？一般做法是定义一个volatile long或定义一个AtomicLong（底层也是volatile long），然后在每个线程中用CAS操作对它进行add操作。这两种做法都是没问题的，功能是正确的、性能也还好，我们继续按照原来的方式使用即可。不过，如果你的项目升级到了JDK 8，还可以进一步提高多线程计数器的性能，让它比传统的volatile long方式更高效。JDK 8新增的LongAdder类（父类是Striped64，包含一些公用方法）就是用来完成这个
Java多线程：JDK5.0的Callable接口与线程池
"Java多线程-JDK5.0新增线程创建方式" 在Java编程中，多线程是处理并发任务的关键技术。随着JDK 5.0的发布，Java引入了两种新的线程创建方式，即实现Callable接口和使用线程池，以增强线程管理的灵活性和效率。 ##...
详解JDK中ExecutorService与Callable和Future对线程的支持
08-29
ExecutorService用于管理和执行线程池中的线程，Callable用于返回某个结果，Future用于获取异步计算的结果。它们之间的紧密相连，共同实现了高效、安全的并发编程。 在实际应用中，我们可以使用ExecutorService、...
Java多线程-JDK5.0新增线程创建方式
最新发布
02-03
### Java多线程-JDK5.0新增线程创建方式 #### 一、新增方式1：实现Callable接口 ##### （1）介绍 自Java 5.0起，为提高线程管理的灵活性与效率，引入了`Callable`接口，这是一种全新的创建线程的方式。与传统的`...
Java多线程编程：Callable源码深度解析
"这篇技术文章主要探讨了Java中的多线程高并发编程，特别是Callable接口的源码分析。作者通过对比Runnable接口，介绍了Callable接口的引入背景和使用方法，并详细剖析了FutureTask、ExecutorService和Future接口在...
JDK中的多线程并发调用
05-15 825
使用JDK1.5中的Executors可以创建线程池实现并发操作,详细实现可查看JDK源码,以下是本人整合的工具类:   package xxx.task; import java.util.ArrayList; import java.util.List; import java.util.concurrent.Callable; import java.util.concurrent....
java 7.多线程
weixin_61049097的博客
05-27 250
基本概念 程序：一段静态代码 进程：正在运行的一个程序，进程可以细化为多个线程，每个线程，拥有自己独立的栈、程序计数器，多个线程共享同一个进程中的结构方法区、堆。 线程：一个程序内部的执行路径 单核CPU与多核CPU 一个java应用程序至少有3个线程，main()主线程，gc()垃圾回收线程，异常处理线程，如果发生异常会影响主线程。 并行：多个cpu执行多个任务 并发：一共cpu“同时”执行多个任务 优点：完成时间相对较短；提高应用程序的响应，对图形化界面更有意义，增强用户体验；提高.
Java学习07-多线程
Darwin的博客
10-31 229
线程 一、Process（进程）和 Thread（线程） 程序是指令和数据的有序集合，本身没有什么运行的含义，是静态的 进程执行中的一段程序，是一个动态的概念。是系统资源分配的单位 通常在一个进程中可以包含多个线程，一个进程中至少有一个线程，线程是CPU调度和执行的单位 如：一个程序可以包含声音，图像，字幕等 注意： 很多多线程是模拟出来的，真正的多线程是有多个CPU，即多核，如服务器。如果模拟出来的多线程，即在一个CPU下，同一个时间点，cpu只能执行一个代码，因为切换很快，所以会有同时
java进阶7-多线程
godfather_001的博客
03-15 750
java进阶7-多线程意义进程与线程进程引入线程作用java程序执行原理线程的创建继承Thread实现Runnable接口线程启动线程生命周期线程的调度与控制调度模式线程优先级Thread.sleep()Thread.yield()t.join()t. interrupt（）正确停止线程线程同步一个线程一个对象守护线程设置守护线程Timer 定时器object与线程 意义 提高cpu的使用率 进程与线程 进程是一个程序，例如 qq，线程是进程任务之一 进程引入线程作用 提高进程使用率 一个线程一个栈，共享
【Java多线程】FutureTask的使用示例
qq_40081941的博客
08-12 263
炎热的夏天，一位少侠到客栈吃杯茶，客栈准备茶水有如下两种方式： 同步 先擦桌子，花费3秒； 再准备茶水，花费3秒； 共花费6秒！ 异步 擦桌子和准备茶水同时进行，各自花费3秒（两个线程同时执行）； 共花费3秒！ public static void main(String[] args) throws ExecutionException, InterruptedException { long startTime = System.currentTimeMillis(); // 开始
Java-使用Callable实现多线程的之JDK源码简单学习实践
吟啸徐行
03-04 625
当提起Java实现多线程时候，我们一般来说是继承Thread类或者实现Runnable接口两种。如果不是很严格的说，还有一种就是使用JDK的java.util.concurrent.Callable实现多线程，这需要结合Thread或者线程池实现。然而昨天参加某某公司电面时候被问到，由于之前简单使用过，没有自信学习过导致面试回答语无伦次。下面就先简单分析一下实现原理和一个自己非常简陋的实习。
JDK源码——Callable类
庄小焱
11-27 175
摘要 实例代码 package com.zhuangxiaoyan.jdk.juc.JucLock; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; /** * @Classname CallableDemo * @Description TODO * @Date 2021/11/27
剖析JDK源码-Callable-(10)
weixin_45295678的博客
01-17 115
剖析JDK源码-Callable-(10) 一、简述 二、接口类的声明 @FunctionalInterface public interface Callable<V> { }
Java高级编程——多线程（JDK5新增创建线程方式Callable，线程池）
ou_yang_mu_ling的博客
08-30 673
创建线程的第三、四种方式一、实现Callable接口1.1与Runnable相比1.2实现步骤二、使用线程池2.12.1.1 背景2.1.2 思路2.1.3 好处2.2 创建线程池2.2.1 Executors.newFixedThreadPool(int n);2.3 管理线程池2.3.1 设置线程池属性 一、实现Callable接口 1.1与Runnable相比 与Runnable相比Callable功能更加强大 相比于run()方法，call()可以有返回值 方法可以抛出异常,被外面的操作捕获 支
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值