并发、并行、串行

我们举个例⼦, 饭店的客户是线程, 菜单是指令, 厨师是cpu。

1、并发(Concurrency)

通俗:并发是多个客户在同⼀时间段内不约⽽同来到饭店,但是都想快点上菜, 却只有⼀个厨 师,厨师想了个办法,给每⼀桌上⼀个菜, 然再轮流炒第2、3....个菜,达到⾬露均沾,不⾄于后 ⾯来的客户闹情绪。

底层和类比:在并发处理中,多个任务在相同的时间段内进行执行,可能会有交叉。这并不意味着同时执行,而是通过快速切换任务的方式,使任务在短时间内交替执行。

类比生活中的例子是,一个人在处理多个任务时,通过快速切换,每个任务都能得到一些进展,但是无法同时处理多个任务。

Task 1 -> Task 2 -> Task 3 -> Task 4
     |        |        |
     V        V        V
    Time

2、并行(Parallel)

通俗:并⾏是多个客户在同⼀时刻⼀起来到饭店,没⼈愿意排队, 好办!饭店有多个厨师, 每桌 安排⼀个厨师,⾼档饭店就是好。

底层和类比:多个任务同时执行,每个任务都有自己的处理单元。这意味着同一时间可以有多个任务在同时进行。

类比生活中的例子是,多个人同时处理不同的任务,每个人专注于自己的任务,互不干扰。

Task 1 ------>
Task 2 ------>
Task 3 ------>
Task 4 ------>
     |
     | Time
     V

3、串行(Serial)

通俗:串⾏就很好理解了,按照客户下单顺序, 先到先得, 厨师按菜单顺序炒菜。 但是后⾯的 客户就要等得⽐较久了, 如果第⼀个客户吃的是满汉全席, 后⾯的客户可能就不想等了。

底层和类比:在串行处理中,任务按顺序逐个执行,每个任务必须等待前一个任务完成后才能开始。这意味着同一时间只有一个任务在执行。

类比生活中的例子是,一个人按照列表上的任务一步一步完成,不进行任何交叉或并行操作。

Task 1 -> Task 2 -> Task 3 -> Task 4

综合

通常来说,我们接触较多的是并发和并行的问题,他俩区别主要是:⼀个是交替执⾏,⼀个是同时执⾏。

而并发是逻辑上看似同时执行任务,但是并行则是物理上同时执行任务。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
首先,计算π的方法主要有两种:蒙特卡罗方法和数学公式法。这里以数学公式法为例,介绍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串行并行并发计算π的示例代码,希望能对您有所帮助。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值