Future和Callable的使用

最新推荐文章于 2023-02-06 23:16:40 发布
最新推荐文章于 2023-02-06 23:16:40 发布
阅读量610 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33371766/article/details/122020801
版权

介绍

 方法get()结合ExecutorService中的submit(Callable<T>)的使用

        方法submit(Callable<T>)可以执行参数为Callable的任务。

        方法get()用于获取返回值。

package cn.java.Concurrency;

import java.util.concurrent.Callable;

/**
 * @author 小石潭记
 * @date 2021/12/19 10:08
 * @Description: ${todo}
 */
public class MyCallable implements Callable<String> {

    private int age;

    public MyCallable(int age) {
        this.age = age;
    }

    @Override
    public String call() throws Exception {
        Thread.sleep(1000);
        return "返回值的年龄是:" + age;
    }
}

package cn.java.Concurrency;

import java.util.concurrent.*;

/**
 * @author 小石潭记
 * @date 2021/12/19 10:09
 * @Description: ${todo}
 */
public class Run {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable myCallable = new MyCallable(100);
        ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 3,
                5L, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>());
        Future<String> future = executor.submit(myCallable);
        System.out.println("main A" + System.currentTimeMillis());
        System.out.println(future.get());
        System.out.println("main B" + System.currentTimeMillis());
    }
}

 main A1639880104748
返回值的年龄是:100
main B1639880105759

 从结果来看，方法get()具有阻塞特性。

 方法get()结合ExecutorService中的submit(Runnable)和isDone()的使用

方法submit()不仅可以传入Callable对象，也可以传入Runnable对象，说明submit方法支持有返回值和无返回值的功能。

package cn.java.Concurrency;

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

/**
 * @author 小石潭记
 * @date 2021/12/19 10:22
 * @Description: ${todo}
 */
public class Run1 {
    public static void main(String[] args) {
        try {
            Runnable runnable = () -> System.out.println("打印的信息");
            ExecutorService executorService = Executors.newCachedThreadPool();
            Future<?> future = executorService.submit(runnable);
            System.out.println("结果" + future.get() + "是否完成" + future.isDone());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

打印的信息
结果null是否完成true

上面的runnable无返回值，方法get()具有阻塞特性，而isDone方法无阻塞特性。

使用ExecutorService接口的方法submit(Runnable, T result)

该方法的第二个参数result可以作为执行结果的返回值，而不需要使用get()方法来进行获得。

package cn.java.Concurrency;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author 小石潭记
 * @date 2021/12/19 10:30
 * @Description: ${todo}
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class UserInfo {
    private String username;
    private String password;
}

package cn.java.Concurrency;

/**
 * @author 小石潭记
 * @date 2021/12/19 10:31
 * @Description: ${todo}
 */
public class MyRunnable implements Runnable {

    private UserInfo userInfo;

    public MyRunnable(UserInfo userInfo) {
        this.userInfo = userInfo;
    }

    @Override
    public void run() {
        userInfo.setUsername("张三");
        userInfo.setPassword("123456");
    }
}

package cn.java.Concurrency;

import java.util.concurrent.*;

/**
 * @author 小石潭记
 * @date 2021/12/19 10:34
 * @Description: ${todo}
 */
public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        UserInfo userInfo = new UserInfo();
        MyRunnable myRunnable = new MyRunnable(userInfo);
        ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 3,
                5L, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
        Future<UserInfo> future = executor.submit(myRunnable, userInfo);
        System.out.println("start:" + System.currentTimeMillis());
        userInfo = future.get();
        System.out.println(userInfo);
        System.out.println("end:" + System.currentTimeMillis());


    }

}

 

 方法cancel(boolean mayInterruptIfRunning)和isCanacelled()的使用

 方法cancel(boolean mayInterruptIfRunning)的参数mayInterrupIfRunning的作用是：如果线程正在运行则是否中断正在运行的线程，在代码中需要使用if(Thread.currentThread().isInterrupted())进行配合。

方法cancel()的返回值代表发送取消任务的命令是否成功完成。

package cn.java.Concurrency;

import java.util.concurrent.*;

/**
 * @author 小石潭记
 * @date 2021/12/19 10:09
 * @Description: ${todo}
 */
public class Run {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable myCallable = new MyCallable(100);
        ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 3,
                5L, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>());
        Future<String> future = executor.submit(myCallable);
        System.out.println("main A" + System.currentTimeMillis());
        System.out.println(future.get());
        System.out.println("main B" + System.currentTimeMillis());

        System.out.println(future.cancel(true) + " " + future.isCancelled());
    }
}

从打印结果来看，线程任务已经运行完毕，线程对象已经销毁，所以cancel方法的返回值是false，代表发送取消的命令并没有成功。如果线程任务没有执行完毕，则调用cancel方法的效果是啥？如下：

package cn.java.Concurrency;

import java.util.concurrent.*;

/**
 * @author 小石潭记
 * @date 2021/12/19 10:09
 * @Description: ${todo}
 */
public class Run {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable myCallable = new MyCallable(100);
        ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 3,
                5L, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>());
        Future<String> future = executor.submit(myCallable);
//        System.out.println("main A" + System.currentTimeMillis());
//        System.out.println(future.get());
//        System.out.println("main B" + System.currentTimeMillis());

        System.out.println(future.cancel(true) + " " + future.isCancelled());
    }
}

 

任务在没有运行完成之前执行了cancel方法返回true，代表成功发送取消的命令。

前面介绍过参数mayInterruptIfRunning具有中断线程的作用，并且需要结合代码if(Thread.currentThread().isInterrupted())来进行实现。

package cn.java.Concurrency;

import java.util.concurrent.Callable;

/**
 * @author 小石潭记
 * @date 2021/12/19 11:18
 * @Description: ${todo}
 */
public class MyCallable1 implements Callable<String> {
    @Override
    public String call() throws Exception {
        int i = 0;
        while (i == 0) {
            if (Thread.currentThread().isInterrupted()) {
                throw new InterruptedException();
            }
            System.out.println("正则运行中...");
        }
        return "我的年龄 100";
    }
}

package cn.java.Concurrency;

import java.util.concurrent.*;

/**
 * @author 小石潭记
 * @date 2021/12/19 10:34
 * @Description: ${todo}
 */
public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        MyCallable1 myCallable1 = new MyCallable1();
        ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 3,
                5L, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
        Future<String> future = executor.submit(myCallable1);
        Thread.sleep(4000);
        System.out.println(future.cancel(true) + " "
        + future.isCancelled());
    }

}

方法get(long timeout, TimeUnit unit)的使用

在指定的最大时间内等待获取返回值。

自定义拒绝策略RejectedExecutionHandler接口的使用

接口RejectedExecutionHandler的主要作用是当线程池关闭后依然有任务要执行时，可以实现一些处理。

package cn.java.Concurrency;

/**
 * @author 小石潭记
 * @date 2021/12/19 11:28
 * @Description: ${todo}
 */
public class MyRunnable1 implements Runnable {

    private String username;

    public MyRunnable1(String username) {
        this.username = username;
    }
    @Override
    public void run() {
        System.out.println(username + "在运行!");
    }
}

package cn.java.Concurrency;

import java.util.concurrent.FutureTask;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * @author 小石潭记
 * @date 2021/12/19 11:26
 * @Description: ${todo}
 */
public class MyRejectedExecutionHandler implements RejectedExecutionHandler {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.out.println(((FutureTask) r).toString() + "被拒绝！");
    }
}

package cn.java.Concurrency;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author 小石潭记
 * @date 2021/12/19 10:34
 * @Description: ${todo}
 */
public class Test2 {
    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 3,
                5L, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
        executor.setRejectedExecutionHandler(new MyRejectedExecutionHandler());
        executor.submit(new MyRunnable1("A"));
        executor.submit(new MyRunnable1("B"));
        executor.submit(new MyRunnable1("C"));
        executor.shutdown();
        executor.submit(new MyRunnable1("D"));
        executor.submit(new MyRunnable1("E"));
    }

}

 方法execute()和submit()的区别

方法execute没有返回值，而submit方法可以有返回值。

方法execute在默认情况下异常直接抛出，不能捕获，但可以通过自定义ThreadFactory的方式进行捕获，而submit方法在默认的情况下，可以catch Execution-Exception捕获异常。 

参考： JAVA并发编程  核心方法与框架 ,高洪岩著 ,P356

小石潭记丶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java并发编程-7.异步请求Future模式
silly8543
05-09 380
Java并发编程-异步请求Future模式
Future 和 Callable 组合
走在命运的左岸
01-16 297
Future 和 Callable 组合 概述 适用场景：有一个很耗时的返回值需要计算，并且这个返回值不是立刻需要的话，那么就可以使用这个组合（ Callable 和 Future ），用另一个线程去计算返回值，而当前线程在使用这个返回值之前可以做其它的操作，等到需要这个返回值时，再通过Future得到该返回值； Future 类基于多线程的Future模式设计 future.get()
java-Callable与Future的应用
热门推荐
心猿意碼
04-12 2万+
目录 一、引言 二、Callable与Runnable 三.Future 三、Callable与Runnable应用 四、FutureTask 五、CompletionService 一、引言 在前面的文章中我们讲述了创建线程的2种方式，一种是直接继承Thread，另外一种就是实现Runnable接口。这2种方式都有一个缺陷就是：在执行完任务之后无法获取执行结果。如果需要获取...
并发编程Future and Callable
Remoa的休闲茶馆
12-10 1535
1、Future及Callable基本介绍： 2、主要方法介绍： 3、Callable与Runnable的主要区别： 4、示例代码及运行结果：
java callable future使用教程
大仕忆的博客
03-25 456
收集 了一下感觉还不错的教程 https://www.cnblogs.com/dolphin0520/p/3949310.html 使用场景 https://blog.csdn.net/m0_37549050/article/details/88806978
Java使用Callable和Future创建线程操作示例
08-25
Java使用Callable和Future创建线程操作示例主要介绍了Java使用Callable和Future创建线程操作，结合实例形式分析了java使用Callable接口和Future类创建线程的相关操作技巧与注意事项。 首先，Java 5开始，Java提供了...
java多线程Future和Callable类示例分享
09-02
而 `Future` 和 `Callable` 的结合使用则能解决这一问题，允许线程执行后返回一个计算结果。 1. `Callable` 类： `Callable` 是一个接口，它定义了一个 `call()` 方法，该方法在新线程中执行并返回一个结果。与 `...
Callable和Future.doc
12-25
Callable 和 Future 是 Java 多线程编程中两个重要的接口，它们在处理异步计算和结果获取方面发挥着关键作用。Callable 与 Runnable 相似，但具有更强大的功能，允许任务返回结果并处理异常。 Callable 接口： ...
Java多线程Callable和Future接口区别
08-19
Java多线程Callable和Future接口是Java语言中两个非常重要的接口，它们都是Java多线程编程中使用的接口，用于描述异步计算的结果。在JavaSE5中引入的Callable是一个具有类型参数的范型，他的类型参数方法表示为方法...
Callable，Future的使用方式
12-18
Callable，Future的使用方式，里面使用了三种使用方式分别是FutureTask，ExecutorService，ExecutorCompletionService
Java并发编程：Callable和Future使用
雨的微笑
04-06 5222
在Java中，创建线程一般有两种方式，一种是继承Thread类，一种是实现Runnable接口。然而，这两种方式的缺点是在线程任务执行结束后，无法获取执行结果。我们一般只能采用共享变量或共享存储区以及线程通信的方式实现获得任务结果的目的。 不过，Java中，也提供了使用Callable和Future来实现获取任务结果的操作。Callable用来执行任务，产生结果，而Future用来获得结果。
多线程基础之Future和Callable
weixin_34204722的博客
05-13 90
JAVA创建线程有三种方式：1.继承thread类（因为java只能单继承，所以不推荐使用此方式）2.实现runnable接口3.实现callable接口当执行无返回参数的线程时使用runnable比较合适，但是当想要获取线程执行的返回结果时runnable就不能满足需求了，所以java内置了Callable和Future。demo如下：import java.util.concurrent.Ca...
java多线程：Future与Callable详解
zhaoliubao1的博客
11-18 248
1.Callable与Runnable的相同点与不同点是什么？ 答：Callable与Runnable接口都需要实现默认方法，Callable实现call()方法，Runnable实现run()方法，他们都能够被线程池调用，但是call()有返回值，run()方法没有返回值。 2.call()方法的返回值如何获取？ 答：通过Future的get()方法来获取call()方法的返回值。 例子...
Future和Callable的使用总结
汉南最後の読書人
04-04 5736
在默认的情况下，线程Thread对象不具有返回值的功能，如果在需要取得返回值的情况下是极为不方便的，但在Java1.5的并发包中可以使用Future和Callable来使线程具有返回值的功能。 1.Future和Callable的介绍 接口Callable与线程功能密不可分，但和Runnable的主要区别为: (1) 接口Callable的call()方法可以有返回值，但Runnable接口...
Callable和Future使用
拯救地球好累
09-05 293
Callable和Future的使用
JAVA多线程实现-实现Callable接口
山禾园地
03-19 888
1. 实现Callable接口public class ImplementsCallable implements Callable&lt;Integer&gt;2. 重写接口call()方法，即线程执行内容。    @Override     public Integer call() throws Exception { Thread.currentThread().setName("Thr...
创建线程的方式：3.实现Callable接口
我有满天星辰的博客
05-09 366
实现Callable接口 实现Callable接口，需要返回值类型：implements Callable 重写call方法，需要抛出异常 ：public Boolean call() throws Exception {} 创建目标对象 ：CallableTest callableTest = new CallableTest(); 创建执行服务：ExecutorService service = Executors.newFixedThreadPool(1); 提交执行：Future
【Java多线程】创建多线程方式三：实现Callable接口
qq_64976935的博客
02-06 858
3.FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。1. 可以对具体Runnable、Callable任务的执行结果进行取消、查询是 否完成、获取结果等。2.FutrueTask是Futrue接口的唯一的实现类。实现Callable接口是JDK5.0新增线程创建方式。4.需要借助FutureTask类，比如获取返回结果。1.相比run()方法，可以有返回值。3. 支持泛型的返回值。
Callable和Future使用例子
最新发布
03-04
Callable和Future是Java中用于实现多线程编程的重要类。下面是一个使用Callable和Future的例子： ```java import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.Future; import java.util.concurrent.FutureTask; public class CallableFutureExample { public static void main(String[] args) throws InterruptedException, ExecutionException { Callable<Integer> task = new Callable<Integer>() { @Override public Integer call() throws Exception { int sum = ; for (int i = 1; i <= 100; i++) { sum += i; } return sum; } }; FutureTask<Integer> futureTask = new FutureTask<>(task); Thread thread = new Thread(futureTask); thread.start(); // 等待计算完成，然后获取结果 Integer result = futureTask.get(); System.out.println(result); } } ``` 在这个例子中，我们创建了一个Callable对象，它会计算1到100的和。然后我们将这个Callable对象封装成一个FutureTask对象，并将其传递给一个新的线程。最后，我们调用FutureTask的get()方法来等待计算完成，并获取结果。 输出结果为505，表示1到100的和。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值