Future和Callable --治理线程第二大法宝

最新推荐文章于 2024-04-07 11:47:05 发布
最新推荐文章于 2024-04-07 11:47:05 发布
阅读量96 收藏 1
点赞数
分类专栏： java 并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46008168/article/details/109198866
版权
java 同时被 2 个专栏收录
65 篇文章 0 订阅
订阅专栏
并发
2 篇文章 0 订阅
订阅专栏

在这里插入图片描述
在这里插入图片描述
Runnable的缺陷
在这里插入图片描述

有两大缺陷；
1.不能返回一个返回值，返回值为void
在这里插入图片描述

2.也不能抛出checked Exception
在这里插入图片描述
在run()方法中，无法抛出异常，只能使用try catch 来处理异常；下面的那个对比方法是可以抛出异常的；

为什么又这样的缺陷？
因为它设计的时候，方法返回值为void 而且也设计成无法抛出异常；
Runnable 为什么设计成这样？
如果抛出异常后，就给Thread 这时候没办法处理；所以，就设计成为直接在Runnable中进行处理；
针对于无法抛出检查后异常这个缺陷的补救措施就是Callable接口

Callable接口
在这里插入图片描述
源码如下：
在这里插入图片描述
可以看到第一它又返回值，返回值是泛型；第二，它可以抛出异常；

Future类
Future作用：核心思想，一个方法它的计算可能会很耗时，那么它就会让子线程去执行，然后再去干自己的事情，等他想用这个返回值的时候，再去看他有没有计算出来；如果计算出结果了，就去获取这个值；
Future和Callable的关系
在这里插入图片描述
Future的主要方法 有五个
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
取消的方法
在这里插入图片描述
在这里插入图片描述
完毕不一定是成功执行，失败了，执行完毕也会返回true；
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
代码演示：

package future;

import java.util.Random;
import java.util.concurrent.*;

/**
 * 描述 ： 演示一个Future的使用方法
 */
public class OneFuture {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        Future<Integer> future = service.submit(new CallableTask());
        try {
            // 通过get来获取值，这里需要等待大概3秒钟时间
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        service.shutdown();
    }
    static class CallableTask implements Callable<Integer>{

        @Override
        public Integer call() throws Exception {
            Thread.sleep(3000);
            return new Random().nextInt(1000);
        }
    }
}

结果会是一个随机数；

下面进行lambda表达式,会方便一些；

package future;

import java.util.Random;
import java.util.concurrent.*;

/**
 * 描述 ： 演示一个Future的使用方法，lambda表达式
 */
public class OneFuture {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        Future<Integer> future = service.submit(new Callable() {
            @Override
            public Integer call() throws Exception {
                Thread.sleep(3000);
                return new Random().nextInt(1000);
            }
        });
        try {
            // 通过get来获取值，这里需要等待大概3秒钟时间
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        service.shutdown();
    }

}

多个任务，用Future数组来获取结果；

package future;

import java.util.ArrayList;
import java.util.Random;
import java.util.concurrent.*;

/**
 * 描述： 演示批量提交任务时，用List来批量接收结果；
 */
public class MultiFutures {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(2);
        ArrayList<Future> futures = new ArrayList<>();
        // 提交任务，向数组中提交20个future
        for (int i = 0; i < 20; i++) {
            Future<Integer> future = service.submit(new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    Thread.sleep(3000);
                    return new Random().nextInt(1000);
                }
            });
            futures.add(future);
        }
        // 提交完任务以后，下面的任务还会继续执行
        for (int i = 0; i < 20; i++) {
            Future<Integer> future = futures.get(i);

            try {
                // 注意程序会执行到这里，当这里获取不到的时候，才会进行阻塞
                Integer integer = future.get();
                System.out.println(integer);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }

    }
}

结果是，没3秒中，会打印两个
在这里插入图片描述
任务执行过程中抛出Exception和isDone展示：

package future;

import java.util.concurrent.*;

/**
 * 描述： 演示get方法过程中抛出异常，for循环为了演示抛出Exception的时机：并不是说一产生异常就抛出，
 * 直到我们get执行时，才会抛出
 */
public class GetException {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(20);
        Future<Integer> future = service.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                throw new IllegalAccessException("Callable抛出异常");

            }
        });
        try {
            future.get();
        } catch (InterruptedException e) {
            System.out.println("抛出了InterruptedException异常");
            e.printStackTrace();
        } catch (ExecutionException e) {
            System.out.println("抛出了ExecutionException异常");
            e.printStackTrace();
        }
    }
}

结论如下：
在这里插入图片描述
这里虽然抛出的IllegalAccessException(“Callable抛出异常”)，但是，其抛出的都是ExecutionException。
对其升级：

package future;

import java.util.concurrent.*;

/**
 * 描述： 演示get方法过程中抛出异常，for循环为了演示抛出Exception的时机：并不是说一产生异常就抛出，
 * 直到我们get执行时，才会抛出
 */
public class GetException {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(20);
        Future<Integer> future = service.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                throw new IllegalAccessException("Callable抛出异常");

            }
        });
        try {
            // 其实任务一在线程池中，它就已经是存在了，但是你不会调用get，它是不会抛出的
            for (int i = 0; i < 5; i++) {
                System.out.println(i);
                Thread.sleep(500);
            }
            future.get();
        } catch (InterruptedException e) {
            System.out.println("抛出了InterruptedException异常");
            e.printStackTrace();
        } catch (ExecutionException e) {
            System.out.println("抛出了ExecutionException异常");
            e.printStackTrace();
        }
    }
}

可以证明，只有在调用get的时候，才会抛出异常；
isDone()方法测试
在这里插入图片描述
获取任务超时学习：

package future;

import java.util.concurrent.*;

/**
 * 描述： 演示get的超时方法，需要注意超时后，需要处理，调用future.cancel();
 * 演示cancel传入true和false的区别，
 * 代表是否中断正在执行的任务。
 */
public class Timeout {
    private static final Ad DEFAULT_AD = new Ad("无网络时候的默认广告");

    private static final ExecutorService exec = Executors.newFixedThreadPool(10);

    static class Ad{
        String name;
        public Ad(String name){
            this.name = name;
        }
        @Override
        public String toString(){
            return "Ad{" + "name =" + name + "}";
        }
    }

    static class FetchAdTask implements Callable<Ad> {

        @Override
        public Ad call() throws Exception {
            try {
                Thread.sleep(3000);
            }catch (InterruptedException e){
                System.out.println("sleep期间被中断了");
                return new Ad("被中断时候的默认广告-1");
            }

            return new Ad("有网络的广告");
        }

    }
    public void printAd(){
        Future<Ad> f = exec.submit(new FetchAdTask());
        Ad ad;
        try {
            ad = f.get(4000, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            ad = new Ad("被中断时候的默认广告");
            e.printStackTrace();
        } catch (ExecutionException e) {
            ad = new Ad("被中断时候的默认广告");
            e.printStackTrace();
        } catch (TimeoutException e) {
            ad = new Ad("被中断时候的默认广告");
            System.out.println("超时，未获取到广告");
            boolean cancel = f.cancel(false);
            System.out.println("cancel的结果：" + cancel);
        }
        exec.shutdown();
        System.out.println(ad);
    }

    public static void main(String[] args) {
        Timeout timeout = new Timeout();
        timeout.printAd();
    }
}

在这里插入图片描述
首先，他会去执行printAd()方法，然后，就执行上面的函数，f.get()方法会去获取，在4s内，如果有返回值的话，它就会获取到，而FetchAdTask()任务中，过个3s后，会返回一个有网络的广告；
在这里插入图片描述
在这里插入图片描述

如果，我把这个时间改为2000，那么他就会产生如下结果：
在这里插入图片描述
这时候，会放弃结果；
在这里插入图片描述
但是，当我们f.cancel()中传入true时，这个时候，当一定时间内没获取到的时候，它就会抛出一个异常；
在这里插入图片描述
它会在call()运行的时候，抛出一个异常；就是在Thread.sleep(3000);的过程抛出异常；
在这里插入图片描述
如果填入的是ture，那么就给他一个中断信号，如果填入的是false，那么就不会有中断信号，会继续执行下去；
在这里插入图片描述
如果我们知道该任务可以处理中断，那么就可以调用cancel(true)来处理；
其他的条件一般用false 它也是可以来避免启动尚未启动的任务的；
用FutureTask来创建Future 以前是使用submit()的返回来获得Future的，现在可以使用FuturnTask来获取Future;

在这里插入图片描述
在这里插入图片描述
代码演示：

package future;

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

/**
 * 描述： 演示FutureTask的用法
 */
public class FutureTaskDemo {
    public static void main(String[] args) {
        Task task = new Task();
        FutureTask<Integer> integerFutureTask = new FutureTask<Integer>(task);
        // FutureTask继承Runnable接口，所以，可以这么使用；
        new Thread(integerFutureTask).start();

        try {
            // 使用FutureTask可以把结果进行返回；
            System.out.println("task运行结果：" + integerFutureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }


}

class Task implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("子线程正在计算");
        Thread.sleep(3000);
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum = sum + 1;
        }
        return sum;
    }
}

下面是用线程池来使用；

package future;

import java.util.concurrent.*;

/**
 * 描述： 演示FutureTask的用法
 */
public class FutureTaskDemo {
    public static void main(String[] args) {
        Task task = new Task();
        FutureTask<Integer> integerFutureTask = new FutureTask<Integer>(task);
        /*// FutureTask继承Runnable接口，所以，可以这么使用；
        new Thread(integerFutureTask).start();*/

        ExecutorService service = Executors.newFixedThreadPool(10);
        // 把它放到线程池中进行执行
        service.submit(integerFutureTask);

        try {
            // 使用FutureTask可以把结果进行返回； 也可以来进行调用
            System.out.println("task运行结果：" + integerFutureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }


}

class Task implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("子线程正在计算");
        Thread.sleep(3000);
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum = sum + 1;
        }
        return sum;
    }
}

结果如下：
在这里插入图片描述
在这里插入图片描述
比如说：你获取的第一个future非常慢，那么你后面的future就会被阻塞；
在这里插入图片描述

weixin_46008168
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Future和Callable-治理线程第二大法宝
好想去看海
10-04 149
文章目录1、Runnable缺陷2、Callable接口3、Future类4、两种用法4.1 用法1:线程池submit方法返回future对象4.2 用法2:用FutureTask创建爱你future5、Future的注意点 1、Runnable缺陷 Runnable主要有两个缺陷: 不能返回一个返回值 不能抛出异常 2、Callable接口 这两点Callable都能做到； Future和Callable配合使用:可以用Future.get来获取Callable接口返回的执行结果，还可以通过F
Java使用Callable和Future创建线程操作示例
08-25
Java使用Callable和Future创建线程操作示例主要介绍了Java使用Callable和Future创建线程操作，结合实例形式分析了java使用Callable接口和Future类创建线程的相关操作技巧与注意事项。 首先，Java 5开始，Java提供了...
callable的使用方法详解
qq_49529172的博客
04-16 8587
1.callable的使用方法 2.为何能带有返回值？源码解析
Callable日常使用
weixin_49845828的博客
09-25 2013
Callable日常使用
Callable使用
xiao_yu_gan的博客
02-21 757
Callable与Runnable异同
多线程进阶（下篇）---Callable 接口、JUC（java.util.concurrent) 的常见类、线程池、线程安全的集合类、死锁、其他常见面试题
m0_64247824的博客
05-05 409
本篇包含：Callable 接口、JUC（java.util.concurrent) 的常见类、线程池、线程安全的集合类、死锁、其他常见面试题
JAVA多线程—Callable详解
热门推荐
m0_61160520的博客
07-10 1万+
Callable作为除Thread和Runnable外第三种线程创建方式， - Callable提高响应速度（减少了创建新线程的时间） - Callable降低资源消耗（重复利用线程池中线程，不需要每次都创建） - Callable便于线程管理
详解JDK中ExecutorService与Callable和Future对线程的支持
08-29
Java并发编程中，ExecutorService、Callable和Future是三大核心组件，它们之间紧密相连，共同实现了高效、安全的并发编程。下面我们将详细介绍这些组件的作用和实现原理。 ExecutorService ------------- ...
java多线程Future和Callable类示例分享
09-02
Java多线程编程中，`Future` 和 `Callable` 是两个关键组件，它们共同提供了有返回值的多线程解决方案。通常，我们可以通过继承 `Thread` 类或实现 `Runnable` 接口创建线程，但这些方法无法直接返回计算结果。而 `...
Java多线程Callable和Future接口区别
08-19
Java多线程Callable和Future接口的使用场景非常广泛，如计算复杂的数学问题、处理大规模数据、实现高性能的服务器等等。在这些场景中，我们可以使用Callable和Future接口来实现异步计算，从而提高系统的性能和可扩展...
总结了Thread-Callable-Future的小demo
09-27
自留demo，主要是Thread-Callable-Future的基本实现。 参考文章： 1、深入理解Callable https://blog.csdn.net/qq_19431333/article/details/77483763 2、彻底理解Java的Future模式： ...
Callable的简单使用
weixin_30420305的博客
08-18 233
说起java的线程操作,都会想到Thread和Runable这两个, 这两个类可以实现异步和同步. 在大多数的java开发中, 这两个都是实现异步的线程来使用, 但是现在考虑一种情况: 发出一条线程, 但是得等待这条线程返回结果后, 我们再去发另一个线程. (读者肯定会想到用线程的同步机制做处理) 下面介绍Callable的使用, 也是最近一段时间才学到的新技能, 在这里记录一下。(我的理解...
Callable接口&JUC的常见类
Krive~Irving
07-01 327
Callable接口，JUC的常见类
【多线程】Callable详解
最新发布
m0_74105656的博客
04-07 1125
先看看Callable接口的源码:Callable是一个函数式接口，此时就可以用lambda表达式更简洁地使用它。Callable是个泛型接口，只有一个方法call，该方法返回类型就是传递进来的V类型。call方法还支持抛出异常.
Callable的使用
何星平的博客
08-20 2721
Callable的使用 java多线程的实现方式有4种 继承Thread类，重写run方法； 实现Runnable接口，重写run方法； 实现Callable接口通过FutureTask包装器来创建Thread线程； 通过线程池创建线程； 在这里简单实现一下Callable的方式 public class CallableDemo1 { public static void main...
Java Callable用法
AugusLee的专栏
12-05 428
Callable 和 Runnable 的使用方法大同小异， 区别在于： 1.Callable 使用 call（） 方法， Runnable 使用 run() 方法 2.call() 可以返回值， 而 run()方法不能返回。 3.call() 可以抛出受检查的异常，比如ClassNotFoundException， 而run()不能抛出受检查的异常。 Callable示例如下： [co...
Callable 实战使用
weixin_43726822的博客
07-12 5916
Java并发编程：Callable、Future和FutureTask 在前面的文章中我们讲述了创建线程的2种方式，一种是直接继承Thread，另外一种就是实现Runnable接口。 这2种方式都有一个缺陷就是：在执行完任务之后无法获取执行结果。 如果需要获取执行结果，就必须通过共享变量或者使用线程通信的方式来达到效果，这样使用起来就比较麻烦。 而自从Java 1.5开始，就提供了Callable...
python内置函数callable用法详解
IT之一小佬的博客
02-27 2283
python内置函数callable用法详解
第2关：使用 callable 和 future 创建线程
06-28
可以使用 Python 的 concurrent.futures 库中的 ThreadPoolExecutor 类来使用 callable 和 future 创建线程。首先,需要创建一个 ThreadPoolExecutor 实例,然后使用 submit() 方法将 callable 包装在一个 future 对象...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值