【并发编程】Future模式及JDK中的实现

作者 : 开心源码 本文共5842个字,预计阅读时间需要15分钟 发布时间: 2022-05-12 共271人阅读
1.1、Future模式是什么

先简单举个例子详情,当我们平常写一个函数,函数里的语句一行行同步执行,假如某一行执行很慢,程序就必需等待,直到执行结束才返回结果;但有时我们可能并不急着需要其中某行的执行结果,想让被调使用者立即返回。比方小明在某网站上成功创立了一个账号,创立完账号后会有邮件通知,假如在邮件通知时因某种起因耗时很久(此时账号已成功创立),用传统同步执行的方式那就要等完这个时间才会有创立成功的结果返回到前台,但此时账号创立成功后我们并不需要立即关心邮件发送成功了没,此时即可以用Future模式,让安在后端慢慢解决这个请求,对于调使用者来说,则可以先解决少量其余任务,在真正需要数据的场合(比方某时想要知道邮件发送能否成功)再去尝试获取需要的数据。

用Future模式,获取数据的时候可能无法立即得到需要的数据。而是先拿到一个包装,可以在需要的时候再去get获取需要的数据。

1.2、Future模式与传统模式的区别

先看看请求返回的时序图,显著传统的模式是串行同步执行的,在遇到耗时操作的时候只能等待。反观Future模式,发起一个耗时操作后,函数会立刻返回,并不会阻塞用户端线程。所以在执行实际耗时操作时候用户端无需等待,可以做其余事情,直到需要的时候再向工作线程获取结果。

future.png

2.1、动手实现简易Future模式

下面的DataFuture类只是一个包装类,创立它时无需阻塞等待。在工作线程准备好数据后用setRealData方法将数据传入。用户端只需在真正需要数据时调使用getRealData方法就可,假如此时数据已准备好则立即返回,否则getRealData方法就会等待,直到获取数据完成。

public class DataFuture<T> {    private T realData;    private boolean isOK = false;    public synchronized T getRealData() {        while (!isOK) {            try {                // 数据未准备好则等待                wait();            } catch (Exception e) {                e.printStackTrace();            }        }        return realData;    }        public synchronized void setRealData(T data) {        isOK = true;        realData = data;        notifyAll();    }}

下面实现一服务端,用户端向服务端请求数据时,服务端并不会立刻去加载真正数据,只是创立一个DataFuture,创立子线程去加载真正数据,服务端直接返回DataFuture就可。

public class Server {        public DataFuture<String> getData() {        final DataFuture<String> data = new DataFuture<>();        Executors.newSingleThreadExecutor().execute(new Runnable() {            @Override            public void run() {                try {                    Thread.sleep(5000);                } catch (InterruptedException e) {                    e.printStackTrace();                }                data.setRealData("最终数据");            }        });        return data;    }}

最终用户端调使用 代码如下:

long start = System.currentTimeMillis();Server server = new Server();DataFuture<String> dataFuture = server.getData();try {    // 先执行其余操作    Thread.sleep(5000);    // 模拟耗时...} catch (InterruptedException e) {    e.printStackTrace();}System.out.print("结果数据:" + dataFuture.getRealData());System.out.println("耗时: " + (System.currentTimeMillis() - start));

结果:

结果数据:最终数据耗时: 5021

执行最终数据耗时都在5秒左右,假如串行执行的话就是10秒左右。

2.2、JDK中的Future与FutureTask

先来看看Future接口源码:

public interface Future<V> {    /**     * 使用来取消任务,取消成功则返回true,取消失败则返回false。     * mayInterruptIfRunning参数表示能否允许取消正在执行却没有执行完毕的任务,设为true,则表示可以取消正在执行过程中的任务。     * 假如任务已完成,则无论mayInterruptIfRunning为true还是false,此方法都返回false,即假如取消已经完成的任务会返回false;     * 假如任务正在执行,若mayInterruptIfRunning设置为true,则返回true,若mayInterruptIfRunning设置为false,则返回false;     * 假如任务还没有执行,则无论mayInterruptIfRunning为true还是false,一定返回true。     */    boolean cancel(boolean mayInterruptIfRunning);    /**     * 表示任务能否被取消成功,假如在任务正常完成前被取消成功,则返回true     */    boolean isCancelled();    /**     * 表示任务能否已经完成,若任务完成,则返回true     */    boolean isDone();    /**     * 获取执行结果,假如最终结果还没得出该方法会产生阻塞,直到任务执行完毕返回结果     */    V get() throws InterruptedException, ExecutionException;    /**     * 获取执行结果,假如在指定时间内,还没获取到结果,则抛出TimeoutException     */    V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;}

从上面源码可看出Future就是对于Runnable或者Callable任务的执行进行查询、中断任务、获取结果。下面就以一个计算1到1亿的和为例子,看用传统方式和用Future耗时差多少。先看传统方式代码:

public class FutureTest {    public static void main(String[] args) {        long start = System.currentTimeMillis();        List<Integer> retList = new ArrayList<>();        // 计算1000次1至1亿的和        for (int i = 0; i < 1000; i++) {            retList.add(Calc.cal(100000000));        }        System.out.println("耗时: " + (System.currentTimeMillis() - start));        for (int i = 0; i < 1000; i++) {            try {                Integer result = retList.get(i);                System.out.println("第" + i + "个结果: " + result);            } catch (Exception e) {            }        }        System.out.println("耗时: " + (System.currentTimeMillis() - start));    }    public static class Calc implements Callable<Integer> {        @Override        public Integer call() throws Exception {            return cal(10000);        }        public static int cal (int num) {            int sum = 0;            for (int i = 0; i < num; i++) {                sum += i;            }            return sum;        }    }}

执行结果(耗时40+秒):

耗时: 43659第0个结果: 887459712第1个结果: 887459712第2个结果: 887459712...第999个结果: 887459712耗时: 43688

再来看看用Future模式下程序:

public class FutureTest {    public static void main(String[] args) {        long start = System.currentTimeMillis();        ExecutorService executorService = Executors.newCachedThreadPool();        List<Future<Integer>> futureList = new ArrayList<>();        // 计算1000次1至1亿的和        for (int i = 0; i < 1000; i++) {            // 调度执行            futureList.add(executorService.submit(new Calc()));        }        System.out.println("耗时: " + (System.currentTimeMillis() - start));        for (int i = 0; i < 1000; i++) {            try {                Integer result = futureList.get(i).get();                System.out.println("第" + i + "个结果: " + result);            } catch (InterruptedException | ExecutionException e) {            }        }        System.out.println("耗时: " + (System.currentTimeMillis() - start));    }    public static class Calc implements Callable<Integer> {        @Override        public Integer call() throws Exception {            return cal(100000000);        }        public static int cal (int num) {            int sum = 0;            for (int i = 0; i < num; i++) {                sum += i;            }            return sum;        }    }}

执行结果(耗时12+秒):

耗时: 12058第0个结果: 887459712第1个结果: 887459712...第999个结果: 887459712耗时: 12405

可以看到,计算1000次1至1亿的和,用Future模式并发执行最终的耗时比用传统的方式快了30秒左右,用Future模式的效率大大提高。

2.3、FutureTask

说完Future,Future由于是接口不能直接使用来创立对象,就有了下面的FutureTask。
先看看FutureTask的实现:

public class FutureTask<V> implements RunnableFuture<V>

可以看到FutureTask类实现了RunnableFuture接口,接着看RunnableFuture接口源码:

public interface RunnableFuture<V> extends Runnable, Future<V> {    /**     * Sets this Future to the result of its computation     * unless it has been cancelled.     */    void run();}

可以看到RunnableFuture接口继承了Runnable接口和Future接口,也就是说其实FutureTask既可以作为Runnable被线程执行,也可以作为Future得到Callable的返回值。

看下面FutureTask的两个构造方法,可以看出就是为这两个操作准备的。

public FutureTask(Callable<V> var1) {    if (var1 == null) {        throw new NullPointerException();    } else {        this.callable = var1;        this.state = 0;    }}public FutureTask(Runnable var1, V var2) {    this.callable = Executors.callable(var1, var2);    this.state = 0;}

FutureTask用实例:

public class FutureTest {    public static void main(String[] args) {        ExecutorService executor = Executors.newCachedThreadPool();        Calc task = new Calc();        FutureTask<Integer> futureTask = new FutureTask<Integer>(task);        executor.submit(futureTask);        executor.shutdown();    }    public static class Calc implements Callable<Integer> {        @Override        public Integer call() throws Exception {            return cal(100000000);        }        public static int cal (int num) {            int sum = 0;            for (int i = 0; i < num; i++) {                sum += i;            }            return sum;        }    }}
2.4、Future不足之处

上面例子可以看到用Future模式比传统模式效率显著提高了,用Future肯定程度上可以让一个线程池内的任务异步执行;但同时也有个显著的缺点:就是回调无法放到与任务不同的线程中执行,传统回调最大的问题就是不能将控制流分离到不同的事件解决器中。比方主线程要等各个异步执行线程返回的结果来做下一步操作,就必需阻塞在future.get()方法等待结果返回,这时其实又是同步了,假如遇到某个线程执行时间太长时,那情况就更糟了。

到Java8时引入了一个新的实现类CompletableFuture,弥补了上面的缺点,在下篇会讲解CompletableFuture的用。

作者注:原文发表在公号(点击查看),定期分享IT互联网、金融等工作经验心得、人生感悟,欢迎订阅交流,目前就职阿里-移动事业部,需要大厂内推的也可到公众号砸简历,或者查看我个人资料获取。(公号ID:weknow619)。

说明
1. 本站所有资源来源于用户上传和网络,如有侵权请邮件联系站长!
2. 分享目的仅供大家学习和交流,您必须在下载后24小时内删除!
3. 不得使用于非法商业用途,不得违反国家法律。否则后果自负!
4. 本站提供的源码、模板、插件等等其他资源,都不包含技术服务请大家谅解!
5. 如有链接无法下载、失效或广告,请联系管理员处理!
6. 本站资源售价只是摆设,本站源码仅提供给会员学习使用!
7. 如遇到加密压缩包,请使用360解压,如遇到无法解压的请联系管理员
开心源码网 » 【并发编程】Future模式及JDK中的实现

发表回复