Future

Author: CodePrometheus

Future/Future.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

Future/src/FutureAnalysis.java

@@ -0,0 +1,18 @@
+/**
+ * @Author: zzStar
+ * @Date: 10-13-2020 09:34
+ */
+public class FutureAnalysis {
+    /**
+     * Callable & Future 的关系
+     *      Future是一个存储器，它存储了call()这个任务的结果，
+     *      而这个任务的执行时间是无法提前确定的，因为这完全取决于call()方法执行的情况
+     *      相互配合的关系 （运动员和终点线的裁判的关系）
+     */
+
+    /**
+     *  注意点 ->
+     *      当for循环批量获取future的结果时，容易发生一部分线程很慢的情况，get方法调用时应使用timeout加以限制
+     *      future的生命周期不能后退，和线程池的生命周期一样，一旦完全完成了任务，就永远停在了已完成的状态
+     */
+}

Future/src/FutureTaskUsage.java

@@ -0,0 +1,40 @@
+import java.util.concurrent.*;
+
+/**
+ * FutureTask用法
+ *
+ * @Author: zzStar
+ * @Date: 10-13-2020 10:58
+ */
+public class FutureTaskUsage {
+    public static void main(String[] args) {
+        Task task = new Task();
+        FutureTask<Integer> futureTask = new FutureTask<>(task);
+//        Thread thread = new Thread(futureTask);
+//        thread.start();
+
+        ExecutorService service = Executors.newCachedThreadPool();
+        service.submit(futureTask);
+        service.shutdown();
+
+        //拿出结果
+        try {
+            System.out.println(futureTask.get());
+        } catch (InterruptedException | ExecutionException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static class Task implements Callable<Integer> {
+        @Override
+        public Integer call() throws Exception {
+            System.out.println("========");
+            Thread.sleep(3000);
+            int sum = 0;
+            for (int i = 0; i < 10; i++) {
+                sum += i;
+            }
+            return sum;
+        }
+    }
+}

Future/src/GetException.java

@@ -0,0 +1,36 @@
+import java.util.concurrent.*;
+
+/**
+ * 抛出异常的时机
+ * <p>
+ * 注意，无论自定义什么异常，get抛出的都是ExecutionException异常
+ * 且只有执行到get方法是，才会抛出异常
+ *
+ * @Author: zzStar
+ * @Date: 10-13-2020 10:12
+ */
+public class GetException {
+
+    public static void main(String[] args) {
+        ExecutorService service = Executors.newCachedThreadPool();
+        Future<Integer> future = service.submit(new CallableTask());
+        try {
+            System.out.println(future.isDone());
+            System.out.println(future.get());
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+            System.out.println("InterruptedException");
+        } catch (ExecutionException e) {
+            e.printStackTrace();
+            System.out.println("ExecutionException");
+        }
+        service.shutdown();
+    }
+
+    private static class CallableTask implements Callable<Integer> {
+        @Override
+        public Integer call() throws Exception {
+            throw new IllegalArgumentException("callable抛出异常");
+        }
+    }
+}

Future/src/MultiFutures.java

@@ -0,0 +1,41 @@
+import java.util.ArrayList;
+import java.util.Random;
+import java.util.concurrent.*;
+
+/**
+ * 演示批量提交任务时，用list来批量接收结果
+ *
+ * @Author: zzStar
+ * @Date: 10-13-2020 09:57
+ */
+public class MultiFutures {
+    public static void main(String[] args) {
+        ExecutorService service = Executors.newFixedThreadPool(2);
+        ArrayList<Future> futures = new ArrayList<>();
+
+        for (int i = 0; i < 20; i++) {
+            Future<Integer> future = service.submit(new CallableTask());
+            //添加到数组中
+            futures.add(future);
+        }
+
+        //获取结果,将会每两个打印一次
+        for (int i = 0; i < 20; i++) {
+            var future = futures.get(i);
+            try {
+                System.out.println(future.get());
+            } catch (InterruptedException | ExecutionException e) {
+                e.printStackTrace();
+            }
+        }
+        service.shutdown();
+    }
+
+    private static class CallableTask implements Callable<Integer> {
+        @Override
+        public Integer call() throws InterruptedException {
+            Thread.sleep(2000);
+            return new Random().nextInt();
+        }
+    }
+}

Future/src/OneFuture.java

@@ -0,0 +1,35 @@
+import java.util.Random;
+import java.util.concurrent.*;
+
+/**
+ * 演示一个Future的使用方法,get的基本用法，lambda形式
+ *
+ * @Author: zzStar
+ * @Date: 10-13-2020 09:46
+ */
+public class OneFuture {
+    public static void main(String[] args) {
+        ExecutorService service = Executors.newCachedThreadPool();
+        Callable<Integer> callable = () -> {
+            Thread.sleep(2000);
+            return new Random().nextInt();
+        };
+        Future<Integer> future = service.submit(callable);
+        try {
+            System.out.println(future.get());
+        } catch (InterruptedException | ExecutionException e) {
+            e.printStackTrace();
+        }
+        service.shutdown();
+    }
+
+/*
+    static class CallableTask implements Callable<Integer> {
+        @Override
+        public Integer call() throws Exception {
+            Thread.sleep(3000);
+            return new Random().nextInt();
+        }
+    }
+*/
+}

Future/src/RunnableCantThrowsException.java

@@ -0,0 +1,40 @@
+/**
+ * 在run方法中无法抛出checked Exception
+ * <p>
+ * public interface Runnable {
+ * public abstract void run();
+ * }
+ * 方法里声明异常，返回void
+ *
+ * @Author: zzStar
+ * @Date: 10-13-2020 09:24
+ */
+public class RunnableCantThrowsException {
+
+    public static void main(String[] args) {
+        Runnable runnable = () -> {
+            //只能try catch
+            try {
+                throw new Exception();
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        };
+    }
+
+}
+
+/*
+@FunctionalInterface
+public interface Callable<V> {
+    */
+/**
+ * Computes a result, or throws an exception if unable to do so.
+ *
+ * @return computed result
+ * @throws Exception if unable to compute a result
+ *//*
+
+    V call() throws Exception;
+}
+*/

Future/src/Timeout.java

@@ -0,0 +1,75 @@
+import java.util.concurrent.*;
+
+/**
+ * 演示get的超时方法
+ * cancel方法 —> 取消任务的执行
+ * 如果任务已经开始执行了，那么这个取消方法不会直接取消该任务，而是根据传入的参数做判断
+ * <p>
+ * true -> 任务能处理interrupt
+ * false -> 仅用于避免启动尚未启动的任务（适用于未能处理interrupt、不清楚任务是否支持取消、需要等待已经开始的任务执行完成）
+ *
+ * @Author: zzStar
+ * @Date: 10-13-2020 10:21
+ */
+public class Timeout {
+
+    private static final ExecutorService executorService = Executors.newFixedThreadPool(10);
+
+    static class Ad {
+        String name;
+
+        public Ad(String name) {
+            this.name = name;
+        }
+
+        @Override
+        public String toString() {
+            return "Ad{" +
+                    "name='" + name + '\'' +
+                    '}';
+        }
+    }
+
+    //任务 -> 3秒中的时间返回广告
+    static class FetchTask implements Callable<Ad> {
+        @Override
+        public Ad call() {
+            try {
+                Thread.sleep(3000);
+            } catch (InterruptedException e) {
+                System.out.println("sleep期间被中断了");
+                return new Ad("被中断时候的默认广告");
+            }
+            return new Ad("Alibaba");
+        }
+    }
+
+    public void printAd() {
+        Future<Ad> adFuture = executorService.submit(new FetchTask());
+        Ad ad;
+        try {
+            //给出4秒的超时时间
+            ad = adFuture.get(4000, TimeUnit.MILLISECONDS);
+        } catch (InterruptedException e) {
+            ad = new Ad("被中断时候的默认广告");
+        } catch (ExecutionException e) {
+            ad = new Ad("异常时候的默认广告");
+        } catch (TimeoutException e) {
+            ad = new Ad("超时时候的默认广告");
+            System.out.println("超时，未获取到广告");
+
+            //是否中断正在执行的任务
+            //传入false，还未被执行的任务会被标记，任务会被正常取消，未来也不会被执行
+            boolean cancel = adFuture.cancel(false);
+            System.out.println("cancel = " + cancel);
+        }
+        executorService.shutdown();
+        System.out.println(ad);
+    }
+
+    public static void main(String[] args) {
+        Timeout timeout = new Timeout();
+        timeout.printAd();
+    }
+
+}

README.md

@@ -82,5 +82,8 @@ Java并发编程
     期望协作工具类去实现的获取/释放等重要方法
         
      
-    
-    
+## Future    
+    Future接口
+    主要方法
+    FutureTask
+    注意点