JAVA多线程——(三)多线程编程
文章目录
【一】Future
Future应用场景
- 在并发编程中,我们经常用到非阻塞的模型,在之前的多线程的三种实现中,不管是继承thread类还是实现runnable接口,都无法保证获取到之前的执行结果。通过实现Callback接口,并用Future可以来接收多线程的执行结果。
- Future表示一个可能还没有完成的异步任务的结果,针对这个结果可以添加Callback以便在任务执行成功或失败后作出相应的操作。
FutureTask的类图结构
public class Main {
public static Integer consumerFunction(){
System.out.println("这是消费者:");
return 1;
}
public static Integer producerFunction(){
System.out.println("这是生产者:");
return 2;
}
public static void main(String args[]) throws ExecutionException, InterruptedException {
ExecutorService executorService = Executors.newCachedThreadPool();
//生产者
FutureTask<Integer> consumer = new FutureTask<Integer>(()->consumerFunction());
//消费者
FutureTask<Integer> producer = new FutureTask<Integer>(()->producerFunction());
//提交任务
executorService.submit(consumer);
executorService.submit(producer);
int resultProducer = producer.get();
int resultConsumer = consumer.get();
System.out.println("resultConsumer:"+resultConsumer+" resultProducer:"+resultProducer);
}
}
【二】CompletableFuture
CompletableFuture 是一个 Future
CompletableFuture 提供了 join() 方法,它的功能和 get() 方法是一样的,都是阻塞获取值,它们的区别在于 join() 抛出的是 unchecked Exception。
上面的代码确实没什么用,下面介绍几个 static 方法,它们使用任务来实例化一个 CompletableFuture 实例。
CompletableFuture.runAsync(Runnable runnable);
CompletableFuture.runAsync(Runnable runnable, Executor executor);
CompletableFuture.supplyAsync(Supplier<U> supplier);
CompletableFuture.supplyAsync(Supplier<U> supplier, Executor executor)
- runAsync 方法接收的是 Runnable 的实例,意味着它没有返回值
- supplyAsync 方法对应的是有返回值的情况
这两个方法的带 executor 的变种,表示让任务在指定的线程池中执行,不指定的话,通常任务是在 ForkJoinPool.commonPool() 线程池中执行的。
2.1 任务之间执行顺序(串行):
我们先来看执行两个任务的情况,首先执行任务 A,然后将任务 A 的结果传递给任务 B。
其实这里有很多种情况:
任务 A 是否有返回值
任务 B 是否需要任务 A 的返回值
任务 B 是否有返回值,等等。
有个明确的就是,肯定是任务 A 执行完后再执行任务 B。
我们用下面的 6 行代码来说:
CompletableFuture.runAsync(() -> {}).thenRun(() -> {});
CompletableFuture.runAsync(() -> {}).thenAccept(resultA -> {});
CompletableFuture.runAsync(() -> {}).thenApply(resultA -> "resultB");
//任务 A 执行完执行 B,并且 B 不需要 A 的结果
CompletableFuture.supplyAsync(() -> "resultA").thenRun(() -> {});
//任务 A 执行完执行 B,B 需要 A 的结果,但是任务 B 不返回值
CompletableFuture.supplyAsync(() -> "resultA").thenAccept(resultA -> {});
//任务 A 执行完执行 B,B 需要 A 的结果,同时任务 B 有返回值
CompletableFuture.supplyAsync(() -> "resultA").thenApply(resultA -> resultA + " resultB");
前面 3 句代码:演示的是,任务 A 无返回值。第 2 行和第 3 行代码中,resultA 其实是 null。
第 4 句:用的是 thenRun(Runnable runnable),任务 A 执行完执行 B,并且 B 不需要 A 的结果。
第 5 句:用的是 thenAccept(Consumer action),任务 A 执行完执行 B,B 需要 A 的结果,但是任务 B 不返回值。
第 6 句:用的是 thenApply(Function fn),任务 A 执行完执行 B,B 需要 A 的结果,同时任务 B 有返回值。
这一小节说完了,如果任务 B 后面还有任务 C,往下继续调用 .thenXxx() 即可。
2.2 取两个任务的结果(并行)
我们来看怎么让任务 A 和任务 B 同时执行,然后取它们的结果进行后续操作,这里强调的是任务之间的并行工作。
如果使用 Future 的话,我们通常是这么写的:
ExecutorService executorService = Executors.newCachedThreadPool();
Future<String> futureA = executorService.submit(() -> "resultA");
Future<String> futureB = executorService.submit(() -> "resultB");
String resultA = futureA.get();
String resultB = futureB.get();
接下来,我们看看 CompletableFuture 中是怎么写的:
CompletableFuture<String> futureA = CompletableFuture.supplyAsync(() -> "resultA");
CompletableFuture<String> futureB = CompletableFuture.supplyAsync(() -> "resultB");
//使用两个任务的结果 resultA 和 resultB,thenAcceptBoth 表示后续的处理不需要返回值
futureA.thenAcceptBoth(futureB, (resultA, resultB) -> {});
//使用两个任务的结果 resultA 和 resultB,而 thenCombine 表示需要返回值。
futureA.thenCombine(futureB, (resultA, resultB) -> "result A + B");
//如果你不需要 resultA 和 resultB,runAfterBoth 方法。
futureA.runAfterBoth(futureB, () -> {});
第 4句代码:使用两个任务的结果 resultA 和 resultB,thenAcceptBoth 表示后续的处理不需要返回值
第 5 句代码:使用两个任务的结果 resultA 和 resultB,而 thenCombine 表示需要返回值。
第 6句代码:如果你不需要 resultA 和 resultB,runAfterBoth 方法。
2.3 取多个任务的结果(并行)
我们将介绍两个非常简单的静态方法:allOf() 和 anyOf() 方法:
public static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs){...}
public static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs) {...}
- allOf :聚合了多个 CompletableFuture 实例,所以它是没有返回值的
CompletableFuture futureA = CompletableFuture.supplyAsync(() -> "resultA");
CompletableFuture futureB = CompletableFuture.supplyAsync(() -> 123);
CompletableFuture futureC = CompletableFuture.supplyAsync(() -> "resultC");
//并行执行三个任务,但是由于是多个任务,没有返回值
CompletableFuture<Void> future = CompletableFuture.allOf(futureA, futureB, futureC);
// 所以这里的 join() 将阻塞,直到所有的任务执行结束
future.join();
- anyOf :就是只要有任意一个 CompletableFuture 实例执行完成就可以了
CompletableFuture futureA = CompletableFuture.supplyAsync(() -> "resultA");
CompletableFuture futureB = CompletableFuture.supplyAsync(() -> 123);
CompletableFuture futureC = CompletableFuture.supplyAsync(() -> "resultC");
//三个任务只要有一个有返回值了就行
CompletableFuture<Object> future = CompletableFuture.anyOf(futureA, futureB, futureC);
//最后一行的 join() 方法会返回最先完成的任务的结果,
//所以它的泛型用的是 Object,因为每个任务可能返回的类型不同
Object result = future.join();
2.4 异常处理
我们顺便来说下 CompletableFuture 的异常处理。这里我们要介绍两个方法:
public CompletableFuture<T> exceptionally(Function<Throwable, ? extends T> fn);
public <U> CompletionStage<U> handle(BiFunction<? super T, Throwable, ? extends U> fn);
看下面的代码:
CompletableFuture.supplyAsync(() -> "resultA")
.thenApply(resultA -> resultA + " resultB")
.thenApply(resultB -> resultB + " resultC")
.thenApply(resultC -> resultC + " resultD");
上面的代码中,任务 A、B、C、D 依次执行,如果任务 A 抛出异常(当然上面的代码不会抛出异常),那么后面的任务都得不到执行
方式一:
我们在任务 A 中抛出异常,并对其进行处理
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
throw new RuntimeException();
})
.exceptionally(ex -> "errorResultA")
.thenApply(resultA -> resultA + " resultB")
.thenApply(resultB -> resultB + " resultC")
.thenApply(resultC -> resultC + " resultD");
System.out.println(future.join());
方式二:
使用 handle(BiFunction fn) 来处理异常
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "resultA")
.thenApply(resultA -> resultA + " resultB")
// 任务 C 抛出异常
.thenApply(resultB -> {throw new RuntimeException();})
// 处理任务 C 的返回值或异常
.handle(new BiFunction<Object, Throwable, Object>() {
@Override
public Object apply(Object re, Throwable throwable) {
if (throwable != null) {
return "errorResultC";
}
return re;
}
})
.thenApply(resultC -> resultC + " resultD");
System.out.println(future.join());
上面的代码使用了 handle 方法来处理任务 C 的执行结果,上面的代码中,re 和 throwable 必然有一个是 null,它们分别代表正常的执行结果和异常的情况。
当然,它们也可以都为 null,因为如果它作用的那个 CompletableFuture 实例没有返回值的时候,re 就是 null。
【三】Fock_Join
fork/join框架是ExecutorService接口的一个实现,可以帮助开发人员充分利用多核处理器的优势,编写出并行执行的程序,提高应用程序的性能;设计的目的是为了处理那些可以被递归拆分的任务。
fork/join框架与其它ExecutorService的实现类相似,会给线程池中的线程分发任务,不同之处在于它使用了工作窃取算法,所谓工作窃取,指的是对那些处理完自身任务的线程,会从其它线程窃取任务执行。
Fork/Join框架是Java 7提供的一个用于并行执行任务的框架,是一个把大任务分割成若干个小任务,最终汇总每个小任务结果后得到大任务结果的框架。简单来说,Fork就是把一个大任务切分为若干子任务并行的执行,Join就是合并这些子任务的执行结果,最后得到这个大任务的结果。比如计算1+2+…+10000,可以分割成10个子任务,每个子任务分别对1000个数进行求和,最终汇总这10个子任务的结果。
3.1 Fork/Join框架的工作原理
从上面Fork/Join框架的介绍中了解到,Fork/Join框架主要分为几个步骤实现。
1、分割任务。首先我们需要有一个fork类来把大任务分割成子任务,有可能子任务还是很大,所以还需要不停地分割,直到分割出的子任务足够小。
2、执行任务并合并结果。分割的子任务分别放在双端队列里,然后几个启动线程分别从双端队列里获取任务执行。子任务执行完的结果都统一放在一个队列里,启动一个线程从队列里拿数据,然后合并这些数据。
- RecursiveAction:用于没有返回结果的任务,即执行任务后不会返回结果;
- RecursiveTask:用于有返回结果的任务,即执行任务后会返回结果。
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;
public class CountTask extends RecursiveTask<Integer> {
// 阈值,表示拆分为几个子任务
private static final int THRESHOLD = 2;
private int start;
private int end;
public CountTask(int start, int end) {
this.start = start;
this.end = end;
}
@Override
protected Integer compute() {
int sum = 0;
// 如果任务小于等于阈值则计算任务
Boolean canCompute = (end - start) <= THRESHOLD;
if (canCompute) {
for (int i = start; i <= end; i++) {
sum += i;
}
} else {
// 如果任务大于阈值,就分裂成两个子任务计算
int middle = (start + end) / 2;
CountTask leftTask = new CountTask(start, middle);
CountTask rightTask = new CountTask(middle + 1, end);
// 执行子任务
leftTask.fork();
rightTask.fork();
// 等待子任务执行完,并得到其结果
int leftResult=leftTask.join();
int rightResult=rightTask.join();
// 合并子任务
sum = leftResult + rightResult;
}
r
eturn sum;
}
public static void main(String[] args) {
ForkJoinPool forkJoinPool = new ForkJoinPool();
// 生成一个计算任务,负责计算1+2+3+4
CountTask task = new CountTask(1, 4);
// 执行一个任务
Future<Integer> result = forkJoinPool.submit(task);
try {
System.out.println(result.get());
}
catch (InterruptedException e) {
}
catch (ExecutionException e) {
}
}
}
【四】链接
https://blog.csdn.net/striveb/article/details/84140407
https://blog.csdn.net/w605283073/article/details/92418504