Java多线程并行计算

最新推荐文章于 2024-04-26 12:49:51 发布
最新推荐文章于 2024-04-26 12:49:51 发布
阅读量4.1k 收藏 13
点赞数 3
分类专栏： java java并发编程 java8 文章标签： java 并行计算
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/abcdad/article/details/105617273
版权
java并发编程 同时被 3 个专栏收录
10 篇文章 0 订阅
订阅专栏
java
9 篇文章 0 订阅
订阅专栏
java8
5 篇文章 0 订阅
订阅专栏

在实际业务开发中如何降低接口响应时间，即如何提高程序的并行计算能力。

本文主要包含如下内容：
1、顺序执行
2、线程池+Future
3、使用Java8的CompletableFuture
4、使用Guava的ListenableFuture

1、顺序执行

直接上代码：

package com.c306.test;

import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

@Slf4j
public class ParallelTest {

    /**
     * 测试方法
     *
     * @return
     */
    private int testMethod() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return 1;
    }

    /**
     * 顺序执行
     */
    private void test01() {
        long start = System.currentTimeMillis();

        List<Integer> list = new ArrayList<>(5);
        list.add(this.testMethod());
        list.add(this.testMethod());
        list.add(this.testMethod());
        list.add(this.testMethod());
        list.add(this.testMethod());

        log.info("costs: {}ms", System.currentTimeMillis() - start);
    }

    @Test
    public void testSequentialExec() {
        this.test01();
        this.test01();
        this.test01();
    }
}

多次顺序执行耗时结果：

2020-04-19 16:33:43,310+0800 INFO  [main]  com.qx.test.ParallelTest - costs: 5046ms
2020-04-19 16:33:48,329+0800 INFO  [main]  com.qx.test.ParallelTest - costs: 5003ms
2020-04-19 16:33:53,332+0800 INFO  [main]  com.qx.test.ParallelTest - costs: 5003ms

2、线程池+Future

顺序执行确实很慢，所以我们需要并行执行，即同时调用testMethod()这5个方法。每个方法单独开启一个线程异步去执行，全部执行完成输出结果。
注意：这样执行有个问题是，每次调用都需要创建5个线程，线程的创建和销毁都是需要开销的，所以我们使用池化技术

直接上代码：

package com.c306.test;

import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.stream.Collectors;

@Slf4j
public class ParallelTest {

    /**
     * IO密集型建议：2*CPU，因为IO密集型线程不是一直在运行，所以可以配置多一点；
     * CPU密集型建议：因为一直在使用CPU，所以要保证线程数不能太多，可以CPU数+1；
     */
    private ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() + 1);

    /**
     * 测试方法
     *
     * @return
     */
    private int testMethod() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return 1;
    }

    /**
     * 线程池+Future
     */
    private void test02() {
        long start = System.currentTimeMillis();
        Future<Integer> test1 = executor.submit(this::testMethod);
        Future<Integer> test2 = executor.submit(this::testMethod);
        Future<Integer> test3 = executor.submit(this::testMethod);
        Future<Integer> test4 = executor.submit(this::testMethod);
        Future<Integer> test5 = executor.submit(this::testMethod);
        List<Future<Integer>> futureList = Arrays.asList(test1, test2, test3, test4, test5);

        List<Integer> list = futureList.stream().map(future -> {
            try {
                return future.get();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
            return null;
        }).collect(Collectors.toList());
        log.info("costs: {}ms", System.currentTimeMillis() - start);
    }

    @Test
    public void testFutureExec() {
        this.test02();
        this.test02();
        this.test02();
    }
}

多次并行执行耗时结果：

2020-04-19 16:53:38,983+0800 INFO  [main]  com.qx.test.ParallelTest - costs: 1208ms
2020-04-19 16:53:40,002+0800 INFO  [main]  com.qx.test.ParallelTest - costs: 1000ms
2020-04-19 16:53:41,002+0800 INFO  [main]  com.qx.test.ParallelTest - costs: 1000ms

效果很明显，直接相当于一个方法的调用耗时，这种通过线程池+Future并行计算的方式，直接可以把接口性能提高上去了。

3、使用Java8的CompletableFuture

Future是java.util.concurrent并发包中的接口类，用来表示一个线程异步执行后的结果，核心方法包含：
Future.get() 阻塞调用线程，直到计算结果返回
Future.isDone() 判断线程是否执行完毕
Future.cancel() 取消当前线程的执行

Future.get()是阻塞调用的，想要拿到线程执行的结果，必须是Future.get()阻塞或者while(Future.isDone())轮询方式调用。这种方式叫“主动拉（pull）”，现在流行响应式编程，即“主动推（push）”的方式，当线程执行完了，你告诉我就可以了。

直接上代码：

package com.c306.test;

import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.*;
import java.util.stream.Collectors;

@Slf4j
public class ParallelTest {

    /**
     * IO密集型建议：2*CPU，因为IO密集型线程不是一直在运行，所以可以配置多一点；
     * CPU密集型建议：因为一直在使用CPU，所以要保证线程数不能太多，可以CPU数+1；
     */
    private ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() + 1);

    /**
     * 测试方法
     *
     * @return
     */
    private int testMethod() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return 1;
    }

    /**
     * 使用Java8的CompletableFuture
     */
    private void test03() {
        long start = System.currentTimeMillis();
        List<CompletableFuture<Integer>> futureList = new ArrayList<>(5);
        futureList.add(CompletableFuture.supplyAsync(this::testMethod, executor));
        futureList.add(CompletableFuture.supplyAsync(this::testMethod, executor));
        futureList.add(CompletableFuture.supplyAsync(this::testMethod, executor));
        futureList.add(CompletableFuture.supplyAsync(this::testMethod, executor));
        futureList.add(CompletableFuture.supplyAsync(this::testMethod, executor));

        CompletableFuture<Void> allFuture = CompletableFuture.allOf(futureList.toArray(new CompletableFuture[5]));
        CompletableFuture<List<Integer>> resultList = allFuture.thenApplyAsync(value ->
                        futureList.stream().map(CompletableFuture::join).collect(Collectors.toList()),
                executor
        );
        List<Integer> list = resultList.join();

        log.info("costs: {}ms", System.currentTimeMillis() - start);
    }

    @Test
    public void testCompletableFutureExec() {
        this.test03();
        this.test03();
        this.test03();
    }
}

可以看到实现方式和Future并没有什么不同，但是CompletableFuture提供了很多方便的方法，比如代码中的allOf，thenApplyAsync，可以将多个CompletableFuture组合成一个CompletableFuture，再调用join方法阻塞拿到结果

多次并行执行耗时结果：

2020-04-19 17:08:17,800+0800 INFO  [main]  com.qx.test.ParallelTest - costs: 1212ms
2020-04-19 17:08:18,844+0800 INFO  [main]  com.qx.test.ParallelTest - costs: 1011ms
2020-04-19 17:08:19,847+0800 INFO  [main]  com.qx.test.ParallelTest - costs: 1002ms

CompletableFuture类中有很多方法可以供大家使用，不像Future只要那么几个方法可以使用，这也是Java自有库对Future的一个增强。这里只是简单展示了CompletableFuture的一种用法，实际开发中需要根据不同的场景去选择使用不同的方法。

4、使用Guava的ListenableFuture

谷歌开源的Guava中的ListenableFuture接口对java自带的Future接口做了进一步扩展和封装，并且提供了静态工具类Futures。

直接上代码：

package com.qx.test;

import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.*;
import java.util.stream.Collectors;

@Slf4j
public class ParallelTest {

    /**
     * IO密集型建议：2*CPU，因为IO密集型线程不是一直在运行，所以可以配置多一点；
     * CPU密集型建议：因为一直在使用CPU，所以要保证线程数不能太多，可以CPU数+1；
     */
    private ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() + 1);

    /**
     * 测试方法
     *
     * @return
     */
    private int testMethod() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return 1;
    }

    /**
     * 使用Guava的ListenableFuture
     *
     * @throws ExecutionException
     * @throws InterruptedException
     */
    private void test04() throws ExecutionException, InterruptedException {
        // guava需要包装一下线程池
        ListeningExecutorService listeningExecutorService = MoreExecutors.listeningDecorator(executor);
        long start = System.currentTimeMillis();
        ListenableFuture<Integer> test1 = listeningExecutorService.submit(this::testMethod);
        ListenableFuture<Integer> test2 = listeningExecutorService.submit(this::testMethod);
        ListenableFuture<Integer> test3 = listeningExecutorService.submit(this::testMethod);
        ListenableFuture<Integer> test4 = listeningExecutorService.submit(this::testMethod);
        ListenableFuture<Integer> test5 = listeningExecutorService.submit(this::testMethod);

        ListenableFuture<List<Integer>> listListenableFuture = Futures.allAsList(test1, test2, test3, test4, test5);
        List<Integer> list = listListenableFuture.get();

        log.info("costs: {}ms", System.currentTimeMillis() - start);
    }

    @Test
    public void testListenableFutureExec() throws ExecutionException, InterruptedException {
        this.test04();
        this.test04();
        this.test04();
    }
}

多次并行执行耗时结果：

2020-04-19 17:21:11,919+0800 INFO  [main]  com.qx.test.ParallelTest - costs: 1203ms
2020-04-19 17:21:12,944+0800 INFO  [main]  com.qx.test.ParallelTest - costs: 1002ms
2020-04-19 17:21:13,945+0800 INFO  [main]  com.qx.test.ParallelTest - costs: 1001ms

总结：以上就是如何让接口并行计算的三种实现方式，属于日常开发中比较常用的代码优化技巧。这里没有做过多的说明和比较，需要大家查阅更多的相关源码和资料。

flx_bj
关注
  • 3
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
FutureTask原理解析-java多线程（实现并行计算）
itbird的专栏
09-29 823
FutureTask既然要做到运行完成之前，一旦调用get就会阻塞当前线程，那么必然内部肯定维护了状态。我们看一下状态定义源码《Java并发编程的艺术》一本书中，根据FutureTask.run()方法的执行的时机，把FutureTask的运行状态分为三个阶段未启动：FutureTask.run()方法还没有被执行之前，FutureTask处于未启动状态已启动：FutureTask.run()方法执行之后，处于已启动状态。
Java多线程并发
DeepBlue_的博客
07-26 1410
目录 进程的概念 线程的概念 并发的概念 并行的概念 简单的实例应用 进程的概念 一个在内存中运行的应用程序。每个进程都有自己独立的一块内存空间，一个进程可以拥有多个线程，比如在windows中，一个运行的xx.exe就是一个进程 线程的概念 进程中的一个执行任务（控制单元），负责当前进程中程序的执行。一个进程至少有一个线程，也可以拥有多个线程，多个线程也可以共享数据。 我们可以在windows中的任务管理器看到，我们的CPU在处理中，进程就200多个，但是线程却拥有4000多个，从
Java 多线程之并行流（parallelStream）
QIFU的专栏
12-22 3813
并行流是Java中Stream API的一部分，用于在多核处理器上并行执行流操作。在Java 8及更高版本中引入的Stream API提供了一种新的处理集合的方式，使得开发者能够更轻松地进行数据处理和操作。在使用Stream API时，可以将集合转换为流，然后进行各种操作，例如过滤、映射、排序等。在这个过程中，流可以是串行流（Sequential Stream）或并行流（Parallel Stream）。并行流通过使用多线程并行处理数据，充分利用多核处理器的优势，从而在某些情况下提高处理速度。
Java并发(二)——初次使用多线程并行提高效率
Reische的博客
12-20 392
IO 操作不占用 cpu，只是我们一般拷贝文件使用的是【阻塞 IO】，这时相当于线程虽然不用 cpu，但需要一直等待 IO 结束，没能充分利用线程。但如果是四核 cpu，各个核心分别使用线程 1 执行计算 1，线程 2 执行计算 2，线程 3 执行计算 3，那么 3 个线程是并行的，花费时间只取决于最长的那个线程运行的时间，即。单核 cpu 下，多线程不能实际提高程序运行效率，只是为了能够在不同的任务之间切换，不同线程轮流使用 cpu ，不至于一个线程总占用 cpu，别的线程没法干活。
Java中并行执行任务的多种方式
最新发布
nbsaas-boot基于Request-Response的企业级快速开发框架
04-26 1550
在Java编程中，经常会遇到需要并行执行任务的情况，特别是在处理大量数据或者需要异步处理的场景下。本文将介绍几种常用的并行执行任务的方式，包括使用、并行流、和Future，以及Fork/Join框架。
利用多线程实现加法并行计算
李泽珑李泽珑~~~
05-01 4621
前提：数据规模较小的时候，并行计算可能用时更多利用Callable创建线程，可以返回值。利用future获取返回值。以下是源码：-------------------------------------------------------------------import java.util.Arrays; import java.util.List; import java.util.conc...
你应该这样去开发接口：Java多线程并行计算
xhbzl的博客
09-06 1434
以上就是如何让自己的接口并行计算起来的三种实现方式，属于日常开发中比较常用的一个小技巧，这里没有过多说明这三种方式的具体区别，实际上还需要大家不断的在开发中去使用，查阅更多相关源码和资料，只有等你真正用起来的时候，你才能有所体会！
java多线程并行计算求数组和
记录一名在读研究生的学习笔记、感悟、开发产物
05-23 2016
问题 当面临一个大数组时，要加快数组求和的速度，是否可以将大数组分拆成多个小数组，然后让cpu的多个线程一起执行计算，以加快计算的速度？ 代码 package com.dam.mutiThread.calculateSum; import java.util.Random; public class CalculateSum { //嵌套循环次数，用来增加计算量，更大幅度地体现直接计算和并行计算的区别 private static int cycleTime=10; publi
java 多线程执行不同的运算_JAVA笔记_多线程_异步计算
weixin_42538752的博客
02-13 250
一、Callable，Future，FutureTaskCallable接口与Runnable接口类似，封装了一个异步运行的任务，但与run方法不同，它的call方法可以有一个返回值并且可以抛出异常。Callable接口是个参数化的类型 public interface Callable{ V call() throws Exception} ，类型参数就是返回值的类型。Future接口用于表示...
java 多线程执行不同的运算_java 多线程的经验总结
weixin_39718460的博客
02-16 295
什么是线程？线程是操作系统所能运算调度的最小单元，包含于进程之中，作为进程的实际运作单位；线程与进程的区别，线程是进程的子集，一个进程可以有多个线程，每个线程并行执行不同的任务，不同的进程使用不同的内存空间，而所有线程共享一片相同的内存空间，但是每个线程都拥有单独的栈内存用来储存本地数据Java中实现线程在语言层面上存在两种方式实现，java.lang.Thread 类的实例就是一个线程但是它需要...
Java多线程 - 并行/并发/进程/线程/多线程意义
你今天真好看呀
02-16 2449
1. 并行和并发有什么区别？ 并发和并行都可以处理“多任务”，二者的主要区别在于是否是“同时进行”多个的任务。 串行：按先后顺序做多件事情；例如：A事情完成，才能做B事情； 并行：指同一时刻同时做多件事情；比如：A事情和B事情同时进行； 并发：指同一时间间隔内做多件事情；比如：操作系统将CPU的时间片分时让给A事情和B事情，仿佛是同时执行； 并发：不同的代码块交替执行 并行：不同的代码块同时执行 (1) 并行：指在同一时刻，多个指令可以在多个处理器上同时执行。 (2) 并发：指在同一时
基于Java多线程的并行计算技术研究及应用
05-10
基于Java多线程的并行计算技术研究及应用
java8并行计算示例
04-29
并行计算的核心在于任务分解和多线程执行。在Java 8中，`Stream` API 的并行化处理是通过`parallel()`方法实现的，它能够将一个流转换为并行流，从而使得流中的操作可以并行执行。在数列求和问题中，我们可以通过`...
java多线程下载文件
07-14
在“java多线程下载文件”的场景下，主要涉及到以下几个关键知识点： 1. **线程**：Java中的线程是程序执行的最小单位，通过创建和管理线程，可以让一个程序同时执行多个任务。在Java中，可以通过继承`Thread`类或...
多线程并行运算
05-16
在计算机科学领域，多线程并行运算是一种高效利用处理器资源的技术，特别是在现代多核处理器中，它能显著提升程序的执行效率。本篇将深入探讨多线程的概念、优势、实现方式以及如何应用于查找运算。 一、多线程概念...
java利用CountDownLatch实现并行计算
08-26
Java 利用 CountDownLatch 实现并行计算 Java 中的并行计算是一个非常重要的概念，为了提高计算速度和效率，Java 提供了一些工具和类来实现并行计算。CountDownLatch 就是一个非常重要的工具类，它可以帮助我们实现...
java 多线程计算_java创建多线程实现并行计算任务处理
weixin_42510670的博客
02-12 344
package multithreadingTest;class fblib extends Thread{public static Integer fb(Integer n){return n<2?1:fb(n-1)+fb(n-2);}public static void bl1(int n) throws InterruptedException {for (int i=0;iSyst...
多线程并行计算案例
天天向上
12-22 2178
1. 提出问题 计算 1 + 2 + 3 + 4 + … + 997 + 998 + 999+ 1000 = ? 2. 单线程计算 采用的单线程进行累加求和，先算1 + 2 = 3 再算 3 + 3 = 6 再算 6 + 4 = 10，依次类推直至加到1000，其中要累加999次，假设每次累加至少耗时1ms，这样计算则至少需要999ms。 2.1 代码实现 public static void test01() throws InterruptedException{ long sum = 0;
多线程java并行计算π
09-27
多线程Java并行计算π可以通过将计算任务分解成多个子任务，并使用多个线程同时计算这些子任务来实现。可以使用并行计算的方法，例如使用线程池和Callable接口来实现。 下面是一个示例代码，展示了如何使用多线程Java并行计算π： ```java import java.util.concurrent.*; public class ParallelCalculation { private static final int NUM_THREADS = 4; // 设置线程数 private static final long NUM_STEPS = 1000000000L; // 设置步数 public static void main(String[] args) throws InterruptedException, ExecutionException { ExecutorService executor = Executors.newFixedThreadPool(NUM_THREADS); long startTime = System.currentTimeMillis(); // 创建并提交多个计算π的任务 Future<Double>[] futures = new Future[NUM_THREADS]; for (int i = 0; i < NUM_THREADS; i++) { Callable<Double> task = new PiCalculationTask(i * NUM_STEPS / NUM_THREADS, (i + 1) * NUM_STEPS / NUM_THREADS); futures[i] = executor.submit(task); } // 获取所有子任务的计算结果并求和 double sum = 0; for (Future<Double> future : futures) { sum += future.get(); } double pi = sum / NUM_STEPS * 4; long endTime = System.currentTimeMillis(); long totalTime = endTime - startTime; System.out.println("π的近似值: " + pi); System.out.println("总共用时: " + totalTime + "毫秒"); executor.shutdown(); } static class PiCalculationTask implements Callable<Double> { private final long start; private final long end; public PiCalculationTask(long start, long end) { this.start = start; this.end = end; } @Override public Double call() { double sum = 0; for (long i = start; i < end; i++) { double x = (i + 0.5) / NUM_STEPS; sum += 4 / (1 + x * x); } return sum; } } } ``` 通过将计算任务分解成多个子任务，并使用多个线程同时计算这些子任务，可以大大提高计算π的效率。使用线程池可以方便地管理线程，并提供更好的可扩展性和资源管理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值