Future设计模式

ゞ浴缸里的玫瑰 2022-11-29 12:52 157阅读 0赞

## Future设计模式 ##

> 当执行一个操作时，需要执行很长时间的阻塞。而future设计模式可以使并不阻塞当前的执行，让本线程可以继续向下执行。当需要结果的时候我去拿就好了。

创建Future接口

> 这是一个一个未来接口，当方法调用时立即返回一个Future,根据future的get方法可以拿到返回的值。

public interface Future<T> { 
        T get() throws InterruptedException;
    }

创建FutureTask接口

> 这是一个任务接口，这个接口有call方法来执行核心任务

public interface FutureTask<T> { 
        T call() throws InterruptedException;
    }

创建FutureService

用来提交未来的任务FutureTask，在这里当提交任务时就立刻返回一个Future，其他线程可以通过Future的get来同步拿到方法执行的返回值

public class FutureService { 
    
        public <T>Future<T> submit(final FutureTask<T> task){ 
            AsynFuture<T> asynFuture = new AsynFuture();
            new Thread(()->{ 
                T result = null;
                try { 
                    result = task.call();
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                asynFuture.done(result);
            }).start();
    
            return asynFuture;
        }
    }

创建AsynFuture（Future的实现）

> 提供了get()方法，注意get方法是同步的。当线程执行完了会向AsynFuture的setResult放置数据

public class AsynFuture<T> implements Future<T> { 
    
        private volatile boolean done = false;
    
        private T result;
    
        public void done(T result){ 
            synchronized (this){ 
                this.result = result;
                done = true;
                this.notifyAll();
            }
        }
    
        @Override
        public T get() throws InterruptedException { 
            synchronized (this){ 
                while(!done){ 
                    this.wait();
                }
            }
            return result;
        }
    }

创建测试类

public class MainApplication { 
        public static void main(String[] args) throws InterruptedException { 
            FutureService futureService = new FutureService();
            Future<String> future = futureService.submit(() -> { 
                try { 
                    Thread.sleep(5_000);
    
                } catch (Exception e) { 
                    e.printStackTrace();
                }
                return "FINISHED";
            });
            System.out.println("----------------");
            System.out.println(" do others work");
            Thread.sleep(2_000);
            System.out.println("----------------");
            System.out.println(future.get());
    
        }
    }

## 操作结果分析 ##

> 很明显FutureService的submit不会阻塞当前方法的执行，但是当调用Get时此时程序会陷入阻塞，同步等待方法执行完。  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ2NzI1MQ_size_16_color_FFFFFF_t_70_pic_center]

### 存在的问题及解决方案 ###

问题：在以上代码获取result的方式是通过get的方式去询问就算没有准备好数据也要阻塞当前线程。可不可以当准备好自己通知我呢？

解决方式：使用callback回调的方式，在futureService重载submmit方法

public <T> void submit(final FutureTask<T> task, Consumer<T> consumer){ 
            new Thread(()->{ 
                try { 
                    T res = task.call();
                    consumer.accept(res);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }).start();
        }

测试

public class MainApplication2 { 
        public static void main(String[] args) { 
            FutureService futureService = new FutureService();
            futureService.submit(()->{ 
                Thread.sleep(5_000);
                return "测试";
            },MainApplication2::callback);
    
            System.out.println("-----------");
            System.out.println("同步阻塞检测");
            System.out.println("-----------");
    
        }
    
        public static <T> void callback(T res){ 
            System.out.println(res);
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDQ2NzI1MQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20221124/132d6e4ef5bc460094a801303a06e65e.png