Java中Future和FutureTask的示例详解及使用

2024-04-02 19:55

短信预约 -IT技能 免费直播动态提醒

一、Future 接口

当 call()方法完成时，结果必须存储在主线程已知的对象中，以便主线程可以知道该线程返回的结果。为此，可以使用 Future 对象。

将 Future 视为保存结果的对象–它可能暂时不保存结果，但将来会保存（一旦Callable 返回）。Future 基本上是主线程可以跟踪进度以及其他线程的结果的一种方式。要实现此接口，必须重写 5 种方法，这里列出了重要的方法,如下:


public boolean isDone()


public boolean cancel(boolean mayInterruptIfRunning)

用于停止任务。如果尚未启动，它将停止任务。如果已启动，则仅在 mayInterrupt 为 true时才会中断任务。


boolean isCancelled()

如果任务在正常结束之前被取消返回true


public V get() throws InterruptedException, ExecutionException

用于获取任务的结果。如果任务完成，它将立即返回结果，否则将等待任务完成，然后返回结果。


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

如果任务完成，则返回 true，否则返回 false。

Callable 与 Runnable 类似，因为它封装了要在另一个线程上运行的任务，而 Future 用于存储从另一个线程获得的结果。

实际上，Future 也可以与 Runnable 一起使用。要创建线程，需要 Runnable。为了获得结果，需要 future。

二、FutureTask

介绍：当一个线程需要等待另一个线程把某个任务执行完后它才能继续执行，此时可以使用FutureTask。假设有多个线程执行若干任务，每个任务最多只能被执行一次。当多个线程试图同时执行同一个任务时，只允许一个线程执行任务，其他线程需要等待这个任务执行完后才能继续执行。

Java 库具有具体的 FutureTask 类型，该类型实现 Runnable 和 Future，并方便地将两种功能组合在一起。可以通过为其构造函数提供 Callable 来创建FutureTask。然后，将 FutureTask 对象提供给 Thread 的构造函数以创建Thread 对象。因此，间接地使用 Callable 创建线程。

FutureTask状态转换

FutureTask有以下7种状态：

FutureTask任务的运行状态，最初为NEW。运行状态仅在set、setException和cancel方法中转换为终端状态。在完成过程中，状态可能呈现出瞬时值INTERRUPTING(仅在中断运行程序以满足**cancel(true)**的情况下)或者COMPLETING(在设置结果时)状态时。从这些中间状态到最终状态的转换使用成本更低的有序/延迟写，因为值是统一的，需要进一步修改。

state：表示当前任务的运行状态，FutureTask的所有方法都是围绕state开展的，state声明为volatile，保证了state的可见性，当对state进行修改时所有的线程都会看到。

NEW：表示一个新的任务，初始状态

COMPLETING：当任务被设置结果时，处于COMPLETING状态，这是一个中间状态。

NORMAL：表示任务正常结束。

EXCEPTIONAL：表示任务因异常而结束

CANCELLED：任务还未执行之前就调用了cancel(true)方法，任务处于CANCELLED

INTERRUPTING：当任务调用cancel(true)中断程序时，任务处于INTERRUPTING状态，这是一个中间状态。

INTERRUPTED：任务调用cancel(true)中断程序时会调用interrupt()方法中断线程运行，任务状态由INTERRUPTING转变为INTERRUPTED

可能的状态过渡：
1、NEW -> COMPLETING -> NORMAL：正常结束
2、NEW -> COMPLETING -> EXCEPTIONAL：异常结束
3、NEW -> CANCELLED：任务被取消
4、NEW -> INTERRUPTING -> INTERRUPTED：任务出现中断

三、使用 Callable 和 Future

Runnable缺少的一项功能是，当线程终止时（即 run()完成时），我们无法使线程返回结果。

为了支持此功能，Java 中提供了 Callable 接口。不能直接替换 runnable，因为 Thread 类的构造方法根本没有 Callable。

所以我们可以找一个中间人，也就是FutureTask。

案例


class MyThreadA implements Callable {
    @Override
    public Object call() throws Exception {
        System.out.println(Thread.currentThread().getName() + "在call方法里");
        System.out.println(Thread.currentThread().getName() + "线程进入了 call方法，开始睡觉（进行了一些计算）");
        Thread.sleep(10000);
        System.out.println(Thread.currentThread().getName() + "睡醒了");
        return Thread.currentThread().getName() + "返回的：" + System.currentTimeMillis();
    }
}


public class demo1 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<Integer> futureTaskA = new FutureTask<>(new MyThreadA());

        FutureTask<String> futureTaskB = new FutureTask<>(()->{
            System.out.println(Thread.currentThread().getName() + "在call方法里");
            return Thread.currentThread().getName() + "返回的：" + System.currentTimeMillis();
        });

        new Thread(futureTaskA,"线程A").start();
        new Thread(futureTaskB,"线程B").start();

        while (!futureTaskB.isDone()){  //isDone表示FutureTask的计算是否完成
            System.out.println("wait.......");
        }
        System.out.println(futureTaskA.get());
        System.out.println(futureTaskB.get());

        System.out.println(Thread.currentThread().getName() + "结束了");
    }
}

输出结果：

由上图两个线程返回的时间差约等于10秒可以看出，当一个线程（线程B）需要等待（一直wait…）另一个线程（线程A）把某个任务（进行了一些计算）执行完后它才能继续执行，此时可以使用FutureTask。不管futureTaskA.get()和futureTaskB.get()谁在前面，输出结果一定是“线程B返回的：xxx”在“wait…”的后面。假设有多个线程执行若干任务，每个任务最多只能被执行一次。当多个线程试图同时执行同一个任务时，只允许一个线程执行任务，其他线程需要等待这个任务执行完后才能继续执行。

四、小结(FutureTask核心原理)

FutureTask核心原理

在主线程中需要执行比较耗时的操作时，但又不想阻塞主线程时，可以把这些作业交给 Future 对象在后台完成，当主线程将来需要时，就可以通过 Future对象获得后台作业的计算结果或者执行状态。

• 一般 FutureTask 多用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果

• 仅在计算完成时才能检索结果；如果计算尚未完成，则阻塞 get 方法。一旦计算完成，就不能再重新开始或取消计算。get 方法而获取结果只有在计算完成时获取，否则会一直阻塞直到任务转入完成状态，然后会返回结果或者抛出异常。

• get只计算一次，因此 get 方法放到最后。

附：FutureTask在高并发环境下确保任务只执行一次

网上有篇例子，但是中间讲的不是很清楚。我重新梳理了一下。

在很多高并发的环境下，往往我们只需要某些任务只执行一次。这种使用情景FutureTask的特性恰能胜任。举一个例子，假设有一个带key的连接池，当key存在时，即直接返回key对应的对象；当key不存在时，则创建连接。对于这样的应用场景，通常采用的方法为使用一个Map对象来存储key和连接池对应的对应关系，典型的代码如下面所示：


package com.concurrency.chapter15;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReentrantLock;


public class FutureTaskConnection1 {

    private static Map<String, Connection> connectionPool = new HashMap<>();
    private static ReentrantLock lock = new ReentrantLock();

    public static Connection getConnection(String key) {
        try {
            lock.lock();
            Connection connection = connectionPool.get(key);
            if (connection == null) {
                Connection newConnection = createConnection();
                connectionPool.put(key, newConnection);
                return newConnection;
            }
            return connection;
        } finally {
            lock.unlock();
        }
    }

    private static Connection createConnection() {
        try {
            return DriverManager.getConnection("");
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }
}