串行、并行与并发的理解

1 串行和并行

串行是大家排队一个一个来,并行是大家一起上。

2 并发和并行

概念非常相似,难以区分。分别体现在两个方面。

  • 并发(Concurrency),体现在(1)单个处理器;(2)逻辑上同步运行。
  • 并行(Parallelism),体现在(1)多处理器,多核心;(2)物理上同步运行。

2.1 并行的理解

并行,是真正的同时运行--在同一个时刻多个任务同时执行。例如多核处理器上,有多个线程同时执行同一段代码。单核处理器无法在同一时刻执行多个任务,因此无法并行。

2.2 并发的理解

并发有两种描述,一种是形容多个任务的执行状态;另一种是对“并发性”的简称。

2.2.1 多任务执行状态

因为处理器处理特别快,看上去像同步执行。

  • 两个或者多个任务可以在某个重叠的时间段中启动、运行、完成。
  • 并行(多个线程同时执行)一定是并发,两者是包含关系。

3个线程由一个CPU交替执行(并发)。

3个线程同时由多个CPU执行(并行且并发)。

2.2.2 “并发性”的简称

程序的部分可以无序或者同时执行,且不影响最终的执行结果,表示程序具有并发性。

“并发性”在不同核心数计算机上有着不同的表现。对于多核CPU,可以做到真实的同时运行,即并行;对于单核CPU,可以通过多个线程切换时间片交替运行,实现并发。

2.3 是什么让并发和并行成为了可能

  1. CPU的升级。单核CPU一次只能处理一条指令,基于此增加核心数,多线程处理任务,提高效率。
  2. 操作系统的升级。单核CPU可以通过抢占式调度实现多个线程的切换;多线程如何分配核心是有操作系统来决定,开发人员只需要创建并运行多个线程。
  3. 编程语言的升级--支持多线程。

 

  • 8
    点赞
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
首先,计算π的方法主要有两种:蒙特卡罗方法和数学公式法。这里以数学公式法为例,介绍Java串行并行并发计算π的实现方法。 1. 串行计算π 首先,我们可以使用莱布尼茨级数公式来计算π。该公式的计算公式为:π/4 = 1 - 1/3 + 1/5 - 1/7 + 1/9 - 1/11 + ... + (-1)^(n+1)/(2n-1)。我们可以通过循环来计算这个公式,直到达到预设的精度。下面是一个Java串行计算π的示例代码: ``` public class SerialPi { public static void main(String[] args) { long start = System.currentTimeMillis(); int n = 100000000; // 循环次数 double sum = 0.0; for (int i = 1; i <= n; i++) { double item = (i % 2 == 1 ? 1 : -1) * 1.0 / (2 * i - 1); sum += item; } double pi = 4 * sum; long end = System.currentTimeMillis(); System.out.println("Pi: " + pi); System.out.println("Time: " + (end - start) + "ms"); } } ``` 2. 并行计算π 对于计算π这种密集型的计算任务,我们可以使用并行计算来提高计算效率。Java中提供了多线程的机制来实现并行计算。我们可以将计算任务分配给多个线程来同时进行计算,最后将结果进行合并。下面是一个Java并行计算π的示例代码: ``` public class ParallelPi { private static final int NTHREADS = 4; // 线程数量 private static final int N = 100000000; // 循环次数 private static double[] sumArray = new double[NTHREADS]; public static void main(String[] args) throws InterruptedException { long start = System.currentTimeMillis(); Thread[] threads = new Thread[NTHREADS]; for (int i = 0; i < NTHREADS; i++) { int id = i; threads[i] = new Thread(() -> { double sum = 0.0; for (int j = id; j < N; j += NTHREADS) { double item = (j % 2 == 1 ? 1 : -1) * 1.0 / (2 * j - 1); sum += item; } sumArray[id] = sum; }); threads[i].start(); } for (Thread thread : threads) { thread.join(); } double sum = 0.0; for (double item : sumArray) { sum += item; } double pi = 4 * sum; long end = System.currentTimeMillis(); System.out.println("Pi: " + pi); System.out.println("Time: " + (end - start) + "ms"); } } ``` 3. 并发计算π Java中的并发计算可以通过线程池来实现。线程池可以有效地管理线程的数量,避免线程创建和销毁的开销。下面是一个Java并发计算π的示例代码: ``` public class ConcurrentPi { private static final int NTHREADS = 4; // 线程数量 private static final int N = 100000000; // 循环次数 private static double[] sumArray = new double[NTHREADS]; public static void main(String[] args) throws InterruptedException, ExecutionException { long start = System.currentTimeMillis(); ExecutorService executor = Executors.newFixedThreadPool(NTHREADS); List<Future<Double>> futures = new ArrayList<>(); for (int i = 0; i < NTHREADS; i++) { int id = i; futures.add(executor.submit(() -> { double sum = 0.0; for (int j = id; j < N; j += NTHREADS) { double item = (j % 2 == 1 ? 1 : -1) * 1.0 / (2 * j - 1); sum += item; } return sum; })); } double sum = 0.0; for (Future<Double> future : futures) { sum += future.get(); } double pi = 4 * sum; long end = System.currentTimeMillis(); System.out.println("Pi: " + pi); System.out.println("Time: " + (end - start) + "ms"); executor.shutdown(); } } ``` 以上就是Java串行并行并发计算π的示例代码,希望能对您有所帮助。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值