JUC基础05——Callable接口

Callable接口和Future

Callable 的概述

Callable接口是java SE5 在java.util.concurrent 引入的一个泛型接口，它只有一个名为call()的方法，该方法可以抛出任何异常并且返回一个值。定义一个Callable接口的实例，可以提交给Executor框架的submit()方法，该方法将返回一个Future对象，通过这个Future对象我们可以获取计算结果或取消任务

Callable 的使用

使用Callable接口的关键步骤如下：

创建一个类并实现Callable接口，同时也需要实现call方法
new FutureTask对象，传递一个实现Callable接口的类作为构造函数
用Thread进行实例化，传入实现Runnabnle接口的FutureTask的类
最后通过 futureTask.get() 获取到返回值

示例代码如下

java 复制代码

//1 --- 创建类并实现Callable接口 
public class CallableDemo implements Callable<String> {

    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    //实现Call方法
    @Override
    public String call() throws Exception {
        System.out.println();
        return Thread.currentThread().getName();
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
    
        //new FutureTask对象，传递一个实现Callable接口的类作为构造函数
        FutureTask task = new FutureTask(new CallableDemo());
        
        //用Thread进行实例化，传入实现Runnabnle接口的FutureTask的类
        new Thread(task,"A").start();
        
        //最后通过 task.get() 获取到返回值
        String threadName = task.get();
        System.out.println("通过调用Callabled的线程名称是："+ threadName);

    }
}

执行代码，输出结果：

css 复制代码

A

Process finished with exit code 0

注意：

要求获得Callable线程的计算结果，如果没有计算完成就要去获取，会导致阻塞，直到计算完成

2. 多个线程执行一个FutureTask的时候，只会计算一次

3.如果我们要两个线程同时计算任务的话，那么需要这样写，需要定义两个futureTask

java 复制代码

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

/**
 * @ClassName CallDemo
 * @Description CallDemo
 * @Author Avgrado
 * @Date 2023-11-06 14:43
 */
public class CallableDemo implements Callable<String> {

    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    @Override
    public String call() throws Exception {
        System.out.println("调用了Call方法");
        return Thread.currentThread().getName();
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask task1 = new FutureTask(new CallableDemo());
        FutureTask task2 = new FutureTask(new CallableDemo());
        new Thread(task1,"aa").start();
        new Thread(task2,"bb").start();
        System.out.println("获取到的结果"+task1.get());
        System.out.println("获取到的结果"+task2.get());
    }
}

输出结果：

Future的概述

Future接口是Java的并发包(java.util.concurrent)中的一个重要接口，它代表了一个异步计算的结果。Future接口的主要作用是允许程序在异步计算完成之前可以继续执行其他任务，而不需要等待计算完成。

Future接口提供了一些方法来检查计算是否完成、获取计算结果以及取消计算任务。其中最重要的方法是get()方法，它用于获取计算结果。如果计算未完成，get()方法会阻塞等待直到计算完成。如果计算已经完成，那么get()方法会立即返回计算结果

java 复制代码

package java.util.concurrent;


public interface Future<V> {

    
    boolean cancel(boolean mayInterruptIfRunning);

   
    boolean isCancelled();

   
    boolean isDone();

    
    V get() throws InterruptedException, ExecutionException;

    
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

下面是使用Future接口的例子

java 复制代码

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

public class CallableDemo {
    public static void main(String[] args) {
        
        //创建线程池
        ExecutorService executorService = Executors.newSingleThreadExecutor();

        Future<String> future = executorService.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                // 模拟耗时操作  
                Thread.sleep(1000);
                return "Hello, World!";
            }
        });

        executorService.shutdown(); // 关闭线程池，不执行未提交的任务  

        try {
            // 获取任务执行结果，如果任务未完成，会阻塞等待  
            String result = future.get();
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

FutureTask

FutureTask 位于java.util.concurrent 包下，是一个可取消的异步计算任务其结构图如下：

从结构图来看：FutureTask实现了 Runnable 和 Future接口，并方便地将两种功能组合在一起，可以获取执行结果。并且通过构造函数提供Callable来创建FutureTask，适用于那些需要异步计算，并且希望在某个时间点获取结果的场景。它允许你暂停、恢复和取消一个任务。FutureTask的状态包括：

PENDING（等待任务开始）
RUNNING（任务正在运行）
DONE（任务已完成）

FutureTask 适用于执行比较耗时的操作且不能影响主线程的执行，此时可以用FutureTask 去处理耗时的任务，后续通过调用 FutureTask的 isDone() 方法去判断任务是否执行完成，待到任务执行完成后再通过 get() 方法去获取任务结果

需要注意的点：

在计算完成后才能获取到结果，否则调用get方法会阻塞
计算完成之后就不能重新计算或者取消计算