多线程之Future模式

关注

原创最新推荐文章于 2026-06-14 16:57:37 发布 1.3k 阅读 AI 写同款· GEO 优化 ›

等保2.0下可信验证的动态实现与合规实践本文深入解读等保2.0标准中的“可信验证”要求，并重点探讨其动态实现与合规实践。文章阐述了从可信根、信任链到动态验证的核心概念，拆解了不同安全等级的实施差异，并提供了从硬件选型、软件赋能到平台集成的四步落地指南。通过行业案例与避坑心得，为构建覆盖计算环境、区域边界、通信网络和安全管理中心的全链条可信防御体系提供了实用参考。阅读详情

概述：

Futrue模式：对于多线程，如果线程A要等待线程B的结果，那么线程A没必要等待B，直到B有结果，可以先拿到一个未来的Future，等B有结果是再取真实的结果。

主要角色：

Client：发出请求
Server：返回Data对象，立即返回FutureData，并开启Thread线程装配RealData
Data：返回数据的接口
FutureData：Futrue数据，是一个虚拟的数据，需要装配RealData
RealData：真实数据，构造比较慢

时序图：

这里写图片描述

演示代码：

public interface Data {
    String getRequest();
}

public class RealData implements Data {
    private String result;

    public RealData(String request) {
        System.out.println("根据" + request + "进行查询..,要花很久时间");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("操作完毕,获取结果");
        result = "查询结果";
    }

    public String getRequest() {
        return result;
    }
}

public class FutureData implements Data {

    private RealData realData;

    private boolean isReady = false;

    public synchronized String getRequest() {

        while (!isReady) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return this.realData.getRequest();
    }

    public synchronized void setRealData(RealData realData) {
        if (isReady) {
            return;
        }
        this.realData = realData;
        isReady = true;
        notify();
    }
}

public class FutureClient {
    public Data request(final String request) {

        final FutureData futureData = new FutureData();
        // 开启线程执行操作
        new Thread(new Runnable() {
            public void run() {
                RealData realData = new RealData(request);
                futureData.setRealData(realData);
            }
        }).start();

        return futureData;
    }
}

public class Main {

    public static void main(String[] args) {
        FutureClient fClient = new FutureClient();

        Data data = fClient.request("hello,world");

        System.out.println("请求发送成功...");
        System.out.println("干其他的事情...");

        String result = data.getRequest();

        System.out.println(result);
    }
}

JDK实现：

import java.util.concurrent.Callable;

public class RealData implements Callable<String> {
    private String param;

    public RealData(String param) {
        this.param = param;
    }

    // 处理业务逻辑
    public String call() throws Exception {
        //利用sleep来表示任务处理
        Thread.sleep(2000);

        return "这是根据"+param+"处理后返回的结果";
    }
}

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

public class Main {

    public static void main(String[] args) throws Exception {
        Long start = System.currentTimeMillis();

        FutureTask<String> futureTask = new FutureTask<>(new RealData("hello,world"));
        ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(1);
        newFixedThreadPool.submit(futureTask);

        // 表示主线程正在处理其他逻辑,或者业务
        Thread.sleep(1000);

        System.out.println("子线程处理完成后的结果-->" + futureTask.get());

        Long end = System.currentTimeMillis();

        Long useTime = end - start;

        System.out.println("程序运行了-->" + useTime + "毫秒");
    }
}