JAVA多线程高并发学习笔记(三)——Callable、Future和FutureTask

简介: 为什么要是用Callable和Future Runnable的局限性 Executor采用Runnable作为基本的表达形式,虽然Runnable的run方法能够写入日志,写入文件,写入数据库等操作,但是它不能返回一个值,或者抛出一个受检查的异常,有些需要返回值的需求就不能满足了。

为什么要是用Callable和Future

Runnable的局限性

Executor采用Runnable作为基本的表达形式,虽然Runnable的run方法能够写入日志,写入文件,写入数据库等操作,但是它不能返回一个值,或者抛出一个受检查的异常,有些需要返回值的需求就不能满足了。

能够取消

Executor中的任务有四个状态:创建,提交,开始和完成。如果说有些任务执行时间比较长,希望能够取消该任务,Executor中的任务在未开始前是可以取消的,如果已经开始了,只能通过中断的方式来取消。如果使用Callable和Future的结合,可以使用Future的canel方法取消任务,这样就方便多了。

 

一个例子:

import java.util.concurrent.*;

public class Demo1 {

    public static void main(String args[]) throws Exception {
        ServiceTask task = new ServiceTask();
        ExecutorService executor = Executors.newCachedThreadPool();
        Future<Integer> result = executor.submit(task);
        executor.shutdown();
        System.out.println("正在执行任务");
        Thread.sleep(1000);
        System.out.println("task运行结果为:" + result.get());
    }
}

class ServiceTask implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        Thread.sleep(2000);
        int result = 0;
        // 假设一个很庞大的计算
        for(int i=1;i<100;i++){
            for (int j=0;j<i;j++){
                result +=j;
            }
        }
        return result;
    }
}

看一下执行结果:

这个例子就是一个非常简单的使用Callable和Futute的例子,ServiceTask类实现了Callable接口,并返回一个Integer类型的值。

Future<Integer> result = executor.submit(task);这行代码就是构造一个Future。使用其get()方法就能得到最后的运行值。

 好了看完这一个简单的例子,那就来仔细了解一下它们。

了解Callable和Future

Callable

 来看一下callable的代码:

public abstract interface Callable<V> {
    public abstract V call() throws Exception;
}

可以看出它是接口,提到接口就可以明白接口是灵活的,支持传入泛型参数。这个没什么,我们来重点介绍一下Future

Future

首先来看关于它的介绍
Future提供了检查计算是否完成的方法,以等待计算的完成,并获取计算的结果。计算完成后只能使用 get 方法来获取结果,如有必要,计算完成前可以阻塞此方法。取消则由 cancel 方法来执行。还提供了其他方法,以确定任务是正常完成还是被取消了。

来看一下Future的代码

public abstract interface Future<V> {
    public abstract boolean cancel(boolean paramBoolean);

    public abstract boolean isCancelled();

    public abstract boolean isDone();

    public abstract V get() throws InterruptedException, ExecutionException;

    public abstract V get(long paramLong, TimeUnit paramTimeUnit)
            throws InterruptedException, ExecutionException, TimeoutException;
}

提供了五个方法

 

public abstract boolean cancel(boolean paramBoolean)

试图取消任务的执行(注意是试图),因为存在一些任务已完成、已取消或者因为某些原因无法取消的因素,存在着取消失败的可能性。

当canel方法起作用时,有两个情况:

1.任务未开始,则该任务将永远不会运行;

2.任务处于执行状态,paramBoolean表示是否采用中断的方式中断线程。

 

public abstract boolean isCancelled()

如果任务正常取消的,则返回true。

 

 

public abstract boolean isDone();

如果任务已完成,则返回 true。 可能由于正常终止、异常或取消而完成,在所有这些情况中,此方法都将返回 true。

(注意如果调用isCanle方法,那么isDone将始终返回true).

 

public abstract V get() throws InterruptedException, ExecutionException;

重点到了!这是Future获取计算结果的方式之一,使用get方法。(注意这里返回的是Callable中的泛型)

 get方法取决于任务的状态(未开始,运行中,已完成),如果任务已经完成,那么get会立即返回或者抛出一个异常;

如果任务没有完成,那么get将阻塞知道任务完成。如果任务抛出了异常,那么get会将该异常封装成ExecutionException抛出。

 

public abstract V get(long paramLong, TimeUnit paramTimeUnit)
            throws InterruptedException, ExecutionException, TimeoutException;

如果需要在给定时间后获取计算结果,可以使用这个方法,如果超过给定时间之后没有得到计算结果,则抛出TimeoutException。(注意这里返回的是Callable中的泛型)  

 

如何使用

来看代码:

import java.util.concurrent.*;

public class Demo1 {

    public static void main(String args[]) throws Exception {
        // 1.先实例化任务对象
        ServiceTask task = new ServiceTask();
        // 2.实例化Executor框架中的线程池
        ExecutorService executor = Executors.newCachedThreadPool();
        // 3.使用submit方法将任务提交(返回的是一个Future)
        Future<Integer> result = executor.submit(task);
        // 4.记得关闭线程池
        executor.shutdown();
        System.out.println("正在执行任务");
        Thread.sleep(1000);
        // 5.打印最后的结果
        System.out.println("task运行结果为:" + result.get());
    }
}

/**
 * Callable的实现类
 */
class ServiceTask implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        Thread.sleep(2000);
        int result = 0;
        // 假设一个很庞大的计算
        for(int i=1;i<100;i++){
            for (int j=0;j<i;j++){
                result +=j;
            }
        }
        return result;
    }
}

运行结果:

接下来我们来试一下定时取结果:

还是在原来的代码上修改:

import java.util.concurrent.*;

public class Demo1 {

    public static void main(String args[]) throws Exception {
        // 1.先实例化任务对象
        ServiceTask task = new ServiceTask();
        // 2.实例化Executor框架中的线程池
        ExecutorService executor = Executors.newCachedThreadPool();
        // 3.使用submit方法将任务提交(返回的是一个Future)
        Future<Integer> result = executor.submit(task);
        // 4.记得关闭线程池
        executor.shutdown();
        System.out.println("正在执行任务");
        Thread.sleep(1000);
        // 5.设置定时一秒取结果
        System.out.println("task运行结果为:" + result.get(1,TimeUnit.MILLISECONDS));
    }
}

/**
 * Callable的实现类
 */
class ServiceTask implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        //这里睡眠2秒
        Thread.sleep(2000);
        int result = 0;
        // 假设一个很庞大的计算
        for(int i=1;i<100;i++){
            for (int j=0;j<i;j++){
                result +=j;
            }
        }
        return result;
    }
}

来提前猜想一下,首先设置了定时一秒之后取得结果,但是ServiceTask设置两秒的睡眠时间,理应取结果失败,看一下运行结果:

是的,如果在规定时间内无法取到结果,就会返回TimeoutException。

 

谈谈FutureTask

FutureTask是Future的实现类,它继承了RunnableFuture,RunnableFuture实际上继承了Runnable和Future接口。

来看一下使用如何FutureTask:

import java.util.concurrent.*;

public class FutureCallDemo2 {

    public static void main(String args[])throws  Exception{
        // 1.先实例化任务对象
        FutureTaskService task = new FutureTaskService();
        // 2.实例化Executor框架中的线程池
        ExecutorService excutor = Executors.newCachedThreadPool();
        // 3.直接new一个FutureTask
        FutureTask<Long> result = new FutureTask<Long>(task);
        // 4.提交任务
        excutor.submit(result);
        // 5.关闭线程池
        excutor.shutdown();
        System.out.println("主线程正在执行任务");
        System.out.println("task运行结果为:" + result.get());
    }
}

/**
 * 继承Callable接口
 */
class FutureTaskService implements Callable<Long> {

    @Override
    public Long call() throws Exception {
        Thread.sleep(3000);
        // 10的阶乘
        long sum = 1;
        for (int i = 1; i <= 10; i++) {
            sum = sum * i;
        }
        return sum;
    }
}

用法的话其实差不多。

 

总结:

Future和Callable可以实现异构任务,但是有很多值得考虑的地方。

比如一个类使用了两个任务,一个负责渲染页面,一个负责下载图像。

伪代码如下:

//通过获取图像
List<ImageData>ImageDataList = future.get();
for(ImageData data:ImageDataList ){
  //渲染页面
  renderPage(data);    
}

看似并行的执行任务,但是却存在着问题。如果说下载图像的速度远小于渲染页面的速度,那么最终的执行速度就和串行无异了。

所以只有当大量相互独立且同构的任务可以进行并发处理时,才能体现出将任务分到多个任务中带来的性能提升,考虑实际情况再选择使用会带来事半功倍的效果。

 

本文参考:

Java并发编程实战

个人博客网站 http://www.janti.cn
目录
打赏
0
1
0
0
11
分享
相关文章
Opencv学习笔记(十):同步和异步(多线程)操作打开海康摄像头
如何使用OpenCV进行同步和异步操作来打开海康摄像头,并提供了相关的代码示例。
189 1
Opencv学习笔记(十):同步和异步(多线程)操作打开海康摄像头
Java社招面试中的高频考点:Callable、Future与FutureTask详解
大家好,我是小米。本文主要讲解Java多线程编程中的三个重要概念:Callable、Future和FutureTask。它们在实际开发中帮助我们更灵活、高效地处理多线程任务,尤其适合社招面试场景。通过 Callable 可以定义有返回值且可能抛出异常的任务;Future 用于获取任务结果并提供取消和检查状态的功能;FutureTask 则结合了两者的优势,既可执行任务又可获取结果。掌握这些知识不仅能提升你的编程能力,还能让你在面试中脱颖而出。文中结合实例详细介绍了这三个概念的使用方法及其区别与联系。希望对大家有所帮助!
174 60
Java并发编程:深入解析线程池与Future任务
【7月更文挑战第9天】线程池和Future任务是Java并发编程中非常重要的概念。线程池通过重用线程减少了线程创建和销毁的开销,提高了资源利用率。而Future接口则提供了检查异步任务状态和获取任务结果的能力,使得异步编程更加灵活和强大。掌握这些概念,将有助于我们编写出更高效、更可靠的并发程序。
深入理解Java中的FutureTask:用法和原理
【10月更文挑战第28天】`FutureTask` 是 Java 中 `java.util.concurrent` 包下的一个类,实现了 `RunnableFuture` 接口,支持异步计算和结果获取。它可以作为 `Runnable` 被线程执行,同时通过 `Future` 接口获取计算结果。`FutureTask` 可以基于 `Callable` 或 `Runnable` 创建,常用于多线程环境中执行耗时任务,避免阻塞主线程。任务结果可通过 `get` 方法获取,支持阻塞和非阻塞方式。内部使用 AQS 实现同步机制,确保线程安全。
265 3
|
4月前
FFmpeg学习笔记(二):多线程rtsp推流和ffplay拉流操作,并储存为多路avi格式的视频
这篇博客主要介绍了如何使用FFmpeg进行多线程RTSP推流和ffplay拉流操作,以及如何将视频流保存为多路AVI格式的视频文件。
539 0
多线程学习笔记
这篇文章是多线程学习笔记,涵盖了线程与进程的概念、多线程实现方式、线程状态、线程同步与不安全示例、死锁问题以及生产者与消费者问题等多线程编程的关键知识点。
多线程学习笔记
JAVA并发编程系列(13)Future、FutureTask异步小王子
本文详细解析了Future及其相关类FutureTask的工作原理与应用场景。首先介绍了Future的基本概念和接口方法,强调其异步计算特性。接着通过FutureTask实现了一个模拟外卖订单处理的示例,展示了如何并发查询外卖信息并汇总结果。最后深入分析了FutureTask的源码,包括其内部状态转换机制及关键方法的实现原理。通过本文,读者可以全面理解Future在并发编程中的作用及其实现细节。
Java面试题:解释Java内存模型中的内存顺序规则,Java中的线程组(ThreadGroup)的工作原理,Java中的FutureTask的工作原理
Java面试题:解释Java内存模型中的内存顺序规则,Java中的线程组(ThreadGroup)的工作原理,Java中的FutureTask的工作原理
37 0
Java面试题:详细描述Java堆内存的垃圾回收过程,解释Java中的线程池(ThreadPool)的工作原理,解释Java中的FutureTask的工作原理
Java面试题:详细描述Java堆内存的垃圾回收过程,解释Java中的线程池(ThreadPool)的工作原理,解释Java中的FutureTask的工作原理
46 0
多线程 (下) - 学习笔记2
多线程 (下) - 学习笔记
58 1

热门文章

最新文章

AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等