JAVA8-实现一个异步基于事件回调的Future程序 JAVA8-实现一个异步基于事件回调的Future程序前面2个例子（JAVA8-多线程Future设计模式原理,自定义实现一个Future程序、JAVA8-JDK自带Future,Callable,ExecutorService）+该例子，是为了学习CompletableFuture，理解其原理。自定义Future程序代码示例：package com.example.study.java8.funture; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicReference; /** * 实现一个异步基于事件回调的Future程序 */ public class FutureInAction3 { public static void main(String[] args) { Future<String> future = invoke(() -> { try { Thread.sleep(10000L); return "I'm finished."; } catch (InterruptedException e) { return "I'm Error."; } }); //注册一个事件 future.setCompletable(new Completable<String>() { @Override public void completable(String s) { System.out.println(s); } @Override public void excetion(Throwable cause) { System.out.println("Error"); cause.printStackTrace(); } }); //下面就可以执行其它逻辑了。。。 System.out.println("。。。。。。。。。"); System.out.println(future.get()); System.out.println(future.get()); } private static <T> Future<T> invoke(Callable<T> callable) { AtomicReference<T> result = new AtomicReference<>(); AtomicBoolean finished = new AtomicBoolean(false); Future future = new Future() { private Completable<T> completable; @Override public Object get() { return result.get(); } @Override public boolean isDone() { return finished.get(); } @Override public void setCompletable(Completable completable) { this.completable = completable; } @Override public Completable getCompletable() { return completable; } }; Thread t = new Thread(() -> { try { T value = callable.action(); result.set(value); finished.set(true); if (future.getCompletable() != null) { //调用回调函数 future.getCompletable().completable(value); } } catch (Exception cause) { if (future.getCompletable() != null) { future.getCompletable().excetion(cause); } } }); t.start(); return future; } /** * 自定义的Future * * @param <T> */ private interface Future<T> { T get(); boolean isDone(); void setCompletable(Completable<T> completable); Completable<T> getCompletable(); } private interface Callable<T> { T action(); } /** * 回调接口 * * @param <T> */ private interface Completable<T> { /** * 执行完后，调用的回调函数 * * @param t */ void completable(T t); /** * 执行过程中出现的异常，直接传入需要抛出的异常回调。 * * @param cause */ void excetion(Throwable cause); } }输出结果：。。。。。。。。。 //不会阻塞，继续执行后面操作 null //不会阻塞，继续执行后面操作 null //不会阻塞，继续执行后面操作 I'm finished. //等线程中的操作计算完成后，会根据注册的事件，调用回调函数，输出结果，不用阻塞等待，必须完成后续操作才能执行。

JAVA8-JDK自带Future,Callable,ExecutorService JAVA8-JDK自带Future,Callable,ExecutorService代码示例：package com.example.study.java8.funture; import java.util.List; import java.util.concurrent.*; /** * 和自定义Future中block一样会卡住 */ public class FutureInAction2 { public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException { //创建一个单线程 ExecutorService executorService = Executors.newSingleThreadExecutor(); //返回一个future，里面的操作可能还没完成，但不影响后续的操作。 Future<String> future = executorService.submit(() -> { try { Thread.sleep(10000L); return "I'm finished"; } catch (InterruptedException e) { return "I'm error"; } }); //没有结果会抛出，中断异常 String value = future.get(); System.out.println(value); //关闭进程 executorService.shutdown(); //shutdownNow关闭进程，但是会返回有那些进程还没有执行完。 List<Runnable> runnables = executorService.shutdownNow(); } }输出结果：I'm finished //会阻塞等待操作计算完成，才输出结果。String value = future.get();也可以添加其它参数，设置等待时间，如果超过时间没返回值，就抛出异常。//最后等10秒没拿到，就抛出异常。 String value = future.get(10, TimeUnit.MICROSECONDS);代码示例：package com.example.study.java8.funture; import java.util.List; import java.util.concurrent.*; /** * 和自定义Future中block一样会卡住 */ public class FutureInAction2 { public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException { //创建一个单线程 ExecutorService executorService = Executors.newSingleThreadExecutor(); //返回一个future，里面的操作可能还没完成，但不影响后续的操作。 Future<String> future = executorService.submit(() -> { try { Thread.sleep(10000L); return "I'm finished"; } catch (InterruptedException e) { return "I'm error"; } }); //没有结果会抛出，中断异常 // String value = future.get(); //最后等10秒没拿到，就抛出异常。 String value = future.get(10, TimeUnit.MICROSECONDS); System.out.println(value); //关闭进程 executorService.shutdown(); //shutdownNow关闭进程，但是会返回有那些进程还没有执行完。 List<Runnable> runnables = executorService.shutdownNow(); } }抛出异常结果：Exception in thread "main" java.util.concurrent.TimeoutException at java.base/java.util.concurrent.FutureTask.get(FutureTask.java:204)代码示例：package com.example.study.java8.funture; import java.util.List; import java.util.concurrent.*; /** * 和自定义Future中block一样会卡住 */ public class FutureInAction3 { public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException { //创建一个单线程 ExecutorService executorService = Executors.newSingleThreadExecutor(); //返回一个future，里面的操作可能还没完成，但不影响后续的操作。 Future<String> future = executorService.submit(() -> { try { Thread.sleep(10000L); return "I'm finished"; } catch (InterruptedException e) { return "I'm error"; } }); //判断future里面线程是否执行完成，没有执行完成，则继续等待10秒。 while(!future.isDone()){ Thread.sleep(10); } //最后执行完成，直接可以拿到结果 System.out.println(future.get()); //关闭进程 executorService.shutdown(); //shutdownNow关闭进程，但是会返回有那些进程还没有执行完。 List<Runnable> runnables = executorService.shutdownNow(); } }输出结果：I'm finished //while中会判断是否执行完成，没有完成继续等待，知道执行完成后，直接打印结果

JAVA8-多线程Future设计模式原理,自定义实现一个Future程序 JAVA8-多线程Future设计模式原理,自定义实现一个Future程序。自定义实现Future，理解设计模式原理。Future模式实现自定义代码示例：package com.example.study.java8.funture; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicReference; /** * 自定义模拟future，理解Future的使用。 */ public class FutureInAction { public static void main(String[] args) throws InterruptedException { Funture<String> funture = invoke(() -> { try { //模拟操作计算很长时间 Thread.sleep(10000); return "I'm finished"; } catch (Exception e) { e.printStackTrace(); return "Error"; } }); //操作计算很长时间，还没操作计算完成，只返回了future，虽然此时返回值为null，但是可以接着执行官其它操作,不会阻塞后续操作。 System.out.println(funture.get()); System.out.println(funture.get()); System.out.println(funture.get()); //知道操作计算完成后，将值返回 while (!funture.isDone()) { Thread.sleep(10); } System.out.println(funture.get()); } private static <T> Funture<T> invoke(Callable<T> callable) { AtomicReference<T> result = new AtomicReference<>(); AtomicBoolean finished = new AtomicBoolean(false); Thread t = new Thread(() -> { T value = callable.action(); result.set(value); finished.set(true); }); t.start(); Funture funture = new Funture() { @Override public Object get() { return result.get(); } @Override public boolean isDone() { return finished.get(); } }; return funture; } private interface Funture<T> { T get(); boolean isDone(); } private interface Callable<T> { T action(); } }输出结果：null //这里没有阻塞 null //这里没有阻塞 null //这里没有阻塞 I'm finished //这里没有阻塞null之前没有阻塞，可以之前后续的其它操作。用没有使用Future的方式实现package com.example.study.java8.funture; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicReference; /** * 自定义模拟future，理解Future的使用。 */ public class FutureInAction { public static void main(String[] args) throws InterruptedException { //以前没有future，阻塞方式测试 String str = block(() -> { try { //模拟操作计算很长时间 Thread.sleep(10000); return "I'm finished"; } catch (Exception e) { e.printStackTrace(); return "Error"; } }); //这里就会阻塞等返回结果，再执行下面的其他操作。 System.out.println(str); } //最早的没有future，实现方式 private static <T> T block(Callable<T> callable) { return callable.action(); } private interface Funture<T> { T get(); boolean isDone(); } private interface Callable<T> { T action(); } } 输出结果：I'm finished //这里会阻塞，等很久操作计算完成，才打印结果，后续的其它操作会被阻塞在这里这里会阻塞，等很久操作计算完成，才打印结果，后续的其它操作会被阻塞在这里。