你应该这样去开发接口：Java多线程并行计算

Java多线程对于并行计算来说非常关键，特别是在接口性能方面。
说实话，刚开始做的时候，我很困惑。

按顺序施展这一招，简单粗暴。
就像叫四个哥们干活一样，老王干完就给老李打电话，老李干完就给老张打电话，老张干完就给老刘打电话。
依次调用四个方法。
看一下，四种方法每种都需要1 00ms，所以总时间是4 00ms。
没什么问题，只是慢而已。
代码也很简单：
java 公共字符串顺序执行（）{ 字符串结果1 = 方法1 (); 字符串结果2 = 方法2 (); 字符串结果3 = 方法3 (); 字符串结果4 = 方法4 (); 返回结果1 +结果2 +结果3 +结果4 ； >
线程池+Future，这个东西可以更快。
这是一个高级的动作。
首先创建一个固定大小的线程池，例如 4 个线程。
然后，启动四个方法并并行执行四个任务。
每个方法完成后，我会给你一个 Future，它只是一个占位符，告诉你结果何时准备好。
您可以使用 future.get() 来获取结果，但您必须等待它完成。
然而，由于并行性，总持续时间几乎由最慢方法的持续时间决定。
例如，如果 1 00ms 是最慢的方法，则总持续时间将接近 1 00ms。
代码如下所示：
java ExecutorService 执行器 = Executors.newFixedThreadPool(4 ); Future future1 = executor.submit(() -> method1 ()); Future future2 = executor.submit(() -> method2 ()); Future future3 = executor.submit(() -> method3 ()); Future future4 = executor.submit(() -> method4 ());
String result1 = future1 .get(); 字符串 result2 = future2 .get(); 字符串 result3 = future3 .get(); 字符串 result4 = future4 .get(); 执行器.shutdown(); 返回结果1 + 结果2 + 结果3 + 结果4 ;
CompleteableFuture，这个东西比较高级。
这个来自Java8 的东西功能丰富。
支持链式调用，就像搭积木一样，一个接一个。
CompleteableFuture.supplyAsync 直接执行任务，然后可以用 thenApply 进行后续处理，或者用 thenCombine 合并结果。
这段代码看起来令人耳目一新：
java CompletableFuture future1 = CompletableFuture.supplyAsync(() -> method1 ()); CompletableFuture future2 = CompletableFuture.supplyAsync(() -> method2 ()); CompletableFuture future3 = CompletableFuture.supplyAsync(() -> method3 ()); CompletableFuture future4 = CompletableFuture.supplyAsync(() -> method4 ());
CompletableFuture allFutures = CompletableFuture.allOf(future1 , future2 , future3 , future4 ); CompleteableFuture linkedFuture = allFutures.thenApply(v -> { 尝试{ 返回 future1 .get() + future2 .get() + future3 .get() + future4 .get(); } catch (异常 e) { 抛出新的运行时异常（e）； } }); 返回combineFuture.join();
Guava的ListenableFuture，这个东西有回调。
这是 Google 的大佬们做的，给 Java 原生的 Future 带来了一些改进。
它支持回调，这意味着当任务完成时它会打电话给你，而无需你询问。
Futures.allAsList 将所有 Futures 合并到一个列表中，Futures.addCallback 添加回调。
它适用于你不想被卡住，想做别的事情，并且当结果到达时会通知你的情况。
代码看起来像这个：
java ListeningExecutorService 执行器 = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(4 )); ListenableFuture future1 = executor.submit(() -> method1 ()); ListenableFuture future2 = executor.submit(() -> method2 ()); ListenableFuture future3 = executor.submit(() -> method3 ()); ListenableFuture future4 = executor.submit(() -> method4 ());
ListenableFuture> futures = Futures.allAsList(future1 , future2 , future3 , future4 ); Futures.addCallback(futures, new FutureCallback>() { @覆盖 公共无效 onSuccess(List 结果) { 字符串结果 = results.get(0) + results.get(1 ) + results.get(2 ) + results.get(3 ); //结果处理 >
@Override 公共无效onFailure（Throwable t）{ // 处理异常 } }，执行者）；
总结一下：
线程池+Future，适合简单场景，代码直观，但需要自己管理线程池。

CompletableFuture 功能丰富，链式调用方便，代码看起来清爽。
Guava 的 ListenableFuture 提供了提醒功能，这对于那些不想阻止并想做其他事情的人来说是有好处的。

选择哪一个取决于您的具体场景。
无论业务需求和性能要求是什么，您都必须考虑。

java框架中如何处理并发和多线程？

java 多线程有几种实现方法

1 .Thread类很容易直接继承，但它只是一个接口的实现。
start() 启动一个线程，run() 方法执行一个任务。
2 、如果你的类继承于另一个类，使用Runnable接口实现run()方法，Thread实例调用run()。
3 、JDK1 .5 中引入了ExecutorService、Callable、Future。
Callable 有一个返回值，Future 检索结果。
与ExecutorService结合实现多线程。

如何用Java多线程高效处理大量接口请求？

只有一个核心：线程池+限流。

使用 Executors.newFixedThreadPool 作为固定池。
不要随意设置线程数。
对于处理器数量较多、速度较低的接口，将线程数设置为2 0到5 0。
如果处理器较小且速度较快，则不要创建太多线程。

The task goes directly into the thread pool and uses dispatch.如果某个任务发生异常，不要让线程池爆炸。
用 try-catch 包裹它。

如何获得结果？未来正在付出代价。
信号量用于控制并发。

您需要配置线程池设置，包括核心数量、最大数量和队列大小。
监视 activeCount 和队列大小，并在出现问题时立即纠正它们。

不要随意更改共享数据或锁定它。
You must close it when you run out of resources, otherwise you won't be able to escape.