1、并行

并行代表充分利用多核 cpu 的优势,提高运行效率。

想象下面的场景,执行 3 个计算,最后将计算结果汇总。

计算 1 花费 10 ms

计算 2 花费 11 ms

计算 3 花费 9 ms

汇总需要 1 ms
  • 如果是串行执行,那么总共花费的时间是 10 + 11 + 9 + 1 = 31ms

  • 但如果是四核 cpu,各个核心分别使用线程 1 执行计算 1,线程 2 执行计算 2,线程 3 执行计算 3,那么 3 个线程是并行的,花费时间只取决于最长的那个线程运行的时间,即 11ms 最后加上汇总时间只会花费 12ms

注意

需要在多核 cpu 才能提高效率,单核仍然时是轮流执行

2、设计

1) 环境搭建

  • 基准测试工具选择,使用了比较靠谱的基准测试框架 JMH,它会执行程序预热(会对反复执行的代码进行优化),执行多次测试并平均

  • cpu 核数限制,有两种思路

    1. 建议使用虚拟机,分配合适的核

    2. 使用 msconfig,分配合适的核,需要重启比较麻烦

  • 并行计算方式的选择

    1. 最初想直接使用 parallel stream,后来发现它有自己的问题

    2. 改为了自己手动控制 thread,实现简单的并行计算

  • 引入jar包

    <dependencies>
       <dependency>
           <groupId>org.openjdk.jmh</groupId>
           <artifactId>jmh-core</artifactId>
           <version>1.0</version>
       </dependency>
       <dependency>
           <groupId>org.openjdk.jmh</groupId>
           <artifactId>jmh-generator-annprocess</artifactId>
           <version>1.0</version>
           <scope>provided</scope>
       </dependency>
   </dependencies>

如下代码测试


package org.sample;

import java.util.Arrays;
import java.util.concurrent.FutureTask;

import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.Warmup;

@Fork(1)
@BenchmarkMode(Mode.AverageTime)  //测试模式 这里平均时间
@Warmup(iterations=3) // 热身次数
@Measurement(iterations=5) // 五轮验证
public class MyBenchmark {
static int[] ARRAY = new int[1000_000_00]; // 这里可根据电脑配置调整大小,避免堆溢出错误
static {
Arrays.fill(ARRAY, 1);
}
   // 建立4个线程
   @Benchmark
   public int c() throws Exception {
       int[] array = ARRAY;
       FutureTask<Integer> t1 = new FutureTask<>(()->{
      int sum = 0;
      for(int i = 0; i < 250_000_00;i++) {
      sum += array[0+i];
      }
      return sum;
      });
       FutureTask<Integer> t2 = new FutureTask<>(()->{
      int sum = 0;
      for(int i = 0; i < 250_000_00;i++) {
      sum += array[250_000_00+i];
      }
      return sum;
      });
       FutureTask<Integer> t3 = new FutureTask<>(()->{
      int sum = 0;
      for(int i = 0; i < 250_000_00;i++) {
      sum += array[500_000_00+i];
      }
      return sum;
      });
       FutureTask<Integer> t4 = new FutureTask<>(()->{
      int sum = 0;
      for(int i = 0; i < 250_000_00;i++) {
      sum += array[750_000_00+i];
      }
      return sum;
      });
       new Thread(t1).start();
       new Thread(t2).start();
       new Thread(t3).start();
       new Thread(t4).start();
       return t1.get() + t2.get() + t3.get()+ t4.get();
  }
   // 单线程
   @Benchmark
   public int d() throws Exception {
       int[] array = ARRAY;
       FutureTask<Integer> t1 = new FutureTask<>(()->{
      int sum = 0;
      for(int i = 0; i < 1000_000_00;i++) {
      sum += array[0+i];
      }
      return sum;
      });
       new Thread(t1).start();
       return t1.get();
  }
}

2) 双核 CPU(4个逻辑CPU)

C:\Users\lenovo\eclipse-workspace\test>java -jar target/benchmarks.jar
# VM invoker: C:\Program Files\Java\jdk-11\bin\java.exe
# VM options: <none>
# Warmup: 3 iterations, 1 s each
# Measurement: 5 iterations, 1 s each
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: org.sample.MyBenchmark.c

# Run progress: 0.00% complete, ETA 00:00:16
# Fork: 1 of 1
# Warmup Iteration   1: 0.022 s/op
# Warmup Iteration   2: 0.019 s/op
# Warmup Iteration   3: 0.020 s/op
Iteration   1: 0.020 s/op
Iteration   2: 0.020 s/op
Iteration   3: 0.020 s/op
Iteration   4: 0.020 s/op
Iteration   5: 0.020 s/op


Result: 0.020 ±(99.9%) 0.001 s/op [Average]
Statistics: (min, avg, max) = (0.020, 0.020, 0.020), stdev = 0.000
Confidence interval (99.9%): [0.019, 0.021]


# VM invoker: C:\Program Files\Java\jdk-11\bin\java.exe
# VM options: <none>
# Warmup: 3 iterations, 1 s each
# Measurement: 5 iterations, 1 s each
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: org.sample.MyBenchmark.d

# Run progress: 50.00% complete, ETA 00:00:10
# Fork: 1 of 1
# Warmup Iteration   1: 0.042 s/op
# Warmup Iteration   2: 0.042 s/op
# Warmup Iteration   3: 0.041 s/op
Iteration   1: 0.043 s/op
Iteration   2: 0.042 s/op
Iteration   3: 0.042 s/op
Iteration   4: 0.044 s/op
Iteration   5: 0.042 s/op


Result: 0.043 ±(99.9%) 0.003 s/op [Average]
Statistics: (min, avg, max) = (0.042, 0.043, 0.044), stdev = 0.001
Confidence interval (99.9%): [0.040, 0.045]


# Run complete. Total time: 00:00:20

Benchmark           Mode Samples Score Score error Units
o.s.MyBenchmark.c   avgt        5  0.020        0.001   s/op
o.s.MyBenchmark.d   avgt        5  0.043        0.003   s/op

在最后两行的结论中,可以看到多核下,效率提升还是很明显的,快了一倍左右

3) 单核 CPU

单核cpu建议开虚拟机测试,这里就不验证了。直接看结果

C:\Users\lenovo\eclipse-workspace\test>java -jar target/benchmarks.jar
# VM invoker: C:\Program Files\Java\jdk-11\bin\java.exe
# VM options: <none>
# Warmup: 3 iterations, 1 s each
# Measurement: 5 iterations, 1 s each
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: org.sample.MyBenchmark.c

# Run progress: 0.00% complete, ETA 00:00:16
# Fork: 1 of 1
# Warmup Iteration   1: 0.064 s/op
# Warmup Iteration   2: 0.052 s/op
# Warmup Iteration   3: 1.127 s/op
Iteration   1: 0.053 s/op
Iteration   2: 0.052 s/op
Iteration   3: 0.053 s/op
Iteration   4: 0.057 s/op
Iteration   5: 0.088 s/op


Result: 0.061 ±(99.9%) 0.060 s/op [Average]
Statistics: (min, avg, max) = (0.052, 0.061, 0.088), stdev = 0.016
Confidence interval (99.9%): [0.001, 0.121]


# VM invoker: C:\Program Files\Java\jdk-11\bin\java.exe
# VM options: <none>
# Warmup: 3 iterations, 1 s each
# Measurement: 5 iterations, 1 s each
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: org.sample.MyBenchmark.d

# Run progress: 50.00% complete, ETA 00:00:11
# Fork: 1 of 1
# Warmup Iteration   1: 0.054 s/op
# Warmup Iteration   2: 0.053 s/op
# Warmup Iteration   3: 0.051 s/op
Iteration   1: 0.096 s/op
Iteration   2: 0.054 s/op
Iteration   3: 0.065 s/op
Iteration   4: 0.050 s/op
Iteration   5: 0.055 s/op


Result: 0.064 ±(99.9%) 0.071 s/op [Average]
Statistics: (min, avg, max) = (0.050, 0.064, 0.096), stdev = 0.018
Confidence interval (99.9%): [-0.007, 0.135]


# Run complete. Total time: 00:00:22

Benchmark           Mode Samples Score Score error Units
o.s.MyBenchmark.c   avgt        5  0.061        0.060   s/op
o.s.MyBenchmark.d   avgt        5  0.064        0.071   s/op

可以看到性能几乎是一样的

4) 结论

  1. 单核 cpu 下,多线程不能实际提高程序运行效率,只是为了能够在不同的任务之间切换,不同线程轮流使用 cpu ,不至于一个线程总占用 cpu,别的线程没法干活

  2. 多核 cpu 可以并行跑多个线程,但能否提高程序运行效率还是要分情况的

    • 有些任务,经过精心设计,将任务拆分,并行执行,当然可以提高程序的运行效率。但不是所有计算任务都能拆分

    • 也不是所有任务都需要拆分,任务的目的如果不同,谈拆分和效率没啥意义

  3. IO 操作不占用 cpu,只是我们一般拷贝文件使用的是【阻塞 IO】,这时相当于线程虽然不用 cpu,但需要一直等待 IO 结束,没能充分利用线程。所以才有【非阻塞 IO】和【异步 IO】来提升线程的利用率

Java并发(二)----初次使用多线程并行提高效率的更多相关文章

  1. Java并发(二):基础概念

    并发编程的第二部分,先来谈谈发布(Publish)与逸出(Escape); 发布是指:对象能够在当前作用域之外的代码中使用,例如:将对象的引用传递到其他类的方法中,对象的引用保存在其他类可以访问的地方 ...

  2. JAVA并发编程学习笔记------多线程调优

    1. 多线程场景下尽量使用并发容器代替同步容器 (如ConcurrentHashMap代替同步且基于散列的Map, 遍历操作为主要操作的情况下用CopyOnWriteArrayList代替同步的Lis ...

  3. Java并发编程(03):多线程并发访问,同步控制

    本文源码:GitHub·点这里 || GitEE·点这里 一.并发问题 多线程学习的时候,要面对的第一个复杂问题就是,并发模式下变量的访问,如果不理清楚内在流程和原因,经常会出现这样一个问题:线程处理 ...

  4. 【Java并发编程】:多线程环境中安全使用集合API

    在集合API中,最初设计的Vector和Hashtable是多线程安全的.例如:对于Vector来说,用来添加和删除元素的方法是同步的.如果只有一个线程与Vector的实例交互,那么,要求获取和释放对 ...

  5. java并发(二):初探syncronized

    参考博客 Java多线程系列--"基础篇"04之 synchronized关键字 synchronized基本规则 第一条 当线程访问A对象的synchronized方法和同步块的 ...

  6. Java并发(四)多线程开销

    从单线程应用转变为多线程应用并不只是带来好处.这种转变也会带来一定得开销得.并不是所有时候都要把你的应用编程多线程的.你应该明白这样做确实会带来好处,而且这种好处要比开销大.如果你不确定的话,要试着去 ...

  7. Oracle性能优化之表压缩及并行提高效率的测试

    1.制作测试表 create table t1 as select * from FW_T_GTXLOG insert into t1 select * from t1; create table t ...

  8. 【Java并发专题之一】Java内存模型

    一.计算机内存模型 针对计算机机器而言,操作系统.JVM程序等其他所有程序都需要遵循内存模型规范.1.CPU技术发展1.1 CPU缓存的出现CPU的发展快于内存条,CPU的运算速度越来越快,内存条的读 ...

  9. Java并发编程(3) JUC中的锁

    一 前言 前面已经说到JUC中的锁主要是基于AQS实现,而AQS(AQS的内部结构 .AQS的设计与实现)在前面已经简单介绍过了.今天记录下JUC包下的锁是怎么基于AQS上实现的 二 同步锁 同步锁不 ...

  10. java并发基础知识

    这几天全国都是关键时候,放假了,还是要学习啊!很久没有写博客了,最近看了一本书,有关于java并发编程的,书名叫做“java并发编程之美”,讲的很有意思,这里就做一个笔记吧! 有需要openjdk8源 ...

随机推荐

  1. supper网盘快速下载器

    本人搬砖党喜欢和大家分享一些快速文档 废话少说 很好用,亲测.对有需求的人 速度很快 软件永久有效下载链接:链接: https://pan.baidu.com/s/1g6LIk4mw18Bov0U7D ...

  2. pytorch卷积模块

    nn.Conv2d() 常用的参数有in_channels,out_channels,kernel_size,stride,padding; 除此之外还有参数dilation,groups,bias ...

  3. Unity 转小游戏

    填写appid 和游戏资源位置 在导出的项目里可以修改游戏资源位置 两个目录 minigame 是小程序打开的目录 webgl 是要下载的的资源 下载一个http 服务器就有了 和JS交互 大部分js ...

  4. Maven 中央仓库配置

    Maven 中央仓库配置 Maven 中央仓库地址大全 <!-- 1.阿里中央仓库(首推1) --> <repository> <id>alimaven</i ...

  5. [cisco][LAB]OSPF in NBMA

    NBMA為一種沒有廣播類型的的網路連接,這會使得OSPF建立需要手動設定 拓樸如下: R1# ! interface Loopback0 ip address 172.16.1.1 255.255.2 ...

  6. 过滤器函数 filtes 的使用总结

    // import parseTime, formatTime and set to filter /** * Show plural label if time is plural number * ...

  7. LeetCode 94. 二叉树的中序遍历()

    原题解 题目 约束 题解 方法一 class Solution { public: void inorder(TreeNode* root, vector<int>& res) { ...

  8. Qt Windows上实现毛玻璃效果

    首发于我的个人博客:xie-kang.com 博客内有更多文章,欢迎大家访问 原文地址 前言: 很多人看到这个需求的第一想法都是录制软件窗口后的桌面内容,并且加上个高斯模糊就能实现了. 思路没有错,操 ...

  9. Springboot jar 打包脚本和启动脚本

    说明: SpringBoot极大的提高了工作效率,集成了各大厂优秀的组件,好处就不多说了,使用配置也非常方便,本文主要讲解如何使用更方便的方式打包发布,利用SpringBoot的新特性内置tomcat ...

  10. markdown常用语法及Typora的使用

    一.markdown markdown简介   markdown是一种文档格式,后缀名为.md.markdown非常适于写博客,基本所有博客网站都支持markdown语法格式. 1.标题   mark ...