0Pricing
Java Academy · 课时

并行何时有帮助

工作负载与数据规模因素

并行何时有帮助 是 CoddyKit 上的免费 Java Academy 课时。 这是第 2 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Java Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Java Academy 课程共包含 4 节课。

并行执行需要付出代价

并行执行会增加额外开销：拆分数据、分派任务以及合并结果。只有当节省的时间超过这些开销时，并行执行才值得采用。

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        long sum = IntStream.rangeClosed(1, 10_000_000)
            .parallel()
            .asLongStream()
            .sum();
        System.out.println(sum);
    }
}

因素 1：数据规模（N）

较大的 N 可以分摊并行执行的固定开销。一个粗略经验是，元素数量达到数万后，并行执行才可能值得采用。

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        long count = IntStream.rangeClosed(1, 5_000_000)
            .parallel()
            .filter(n -> n % 7 == 0)
            .count();
        System.out.println(count);
    }
}

因素 2：每个元素的工作量（Q）

处理每个元素的成本 Q 很重要。每个元素都需要大量计算时，即使 N 较小，并行执行也能带来收益。

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        long primes = IntStream.rangeClosed(2, 200_000)
            .parallel()
            .filter(Main::isPrime)
            .count();
        System.out.println(primes);
    }

    static boolean isPrime(int n) {
        for (int i = 2; (long) i * i <= n; i++)
            if (n % i == 0) return false;
        return true;
    }
}

N 乘以 Q 的直观理解

可以将总有效工作量理解为 N x Q。这个乘积越大，并行执行就越有帮助。N 很小或 Q 几乎没有开销时，通常不值得并行。

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        double sum = IntStream.rangeClosed(1, 1_000_000)
            .parallel()
            .mapToDouble(n -> Math.sqrt(n) * Math.log(n + 1))
            .sum();
        System.out.println(sum);
    }
}

因素 3：可拆分性

能够低成本且均匀拆分的数据源适合并行处理：数组、ArrayList 和 IntStream.range。LinkedList 以及基于迭代器的数据源不易拆分。

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

public class Main {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 1_000_000; i++) list.add(i);
        long even = list.parallelStream().filter(n -> n % 2 == 0).count();
        System.out.println(even);
    }
}

良好数据源：数组和范围

基本类型范围的大小已知，并且可以在 O(1) 时间内拆分，因此是理想的并行数据源。

import java.util.stream.LongStream;

public class Main {
    public static void main(String[] args) {
        long sum = LongStream.rangeClosed(1, 20_000_000)
            .parallel()
            .sum();
        System.out.println(sum);
    }
}

较差数据源：迭代式生成器

Stream.iterate 按定义以顺序产生元素，因此必须先生成元素才能拆分。它不是理想的并行数据源。

import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        long count = Stream.iterate(1, n -> n + 1)
            .limit(1_000_000)
            .parallel()
            .filter(n -> n % 2 == 0)
            .count();
        System.out.println(count);
    }
}

因素 4：低成本的合并步骤

并行执行需要一种低成本的方式来合并部分结果。sum 和 count 可以轻松合并；构建有序列表或使用树结构复杂的收集器则需要较高的合并成本。

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int max = IntStream.rangeClosed(1, 5_000_000)
            .parallel()
            .map(n -> n % 1000)
            .max()
            .getAsInt();
        System.out.println(max);
    }
}

避免用于输入输出受限的工作

并行流面向在线程池上运行的受 CPU 限制的任务。阻塞式输入输出会耗尽共享线程池的资源，并影响整个应用程序。对于输入输出操作，请改用专用执行器。

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        long total = IntStream.rangeClosed(1, 1_000_000)
            .parallel()
            .mapToLong(n -> (long) n * n)
            .sum();
        System.out.println(total);
    }
}

进行测量，不要猜测

要可靠判断并行执行是否有帮助，唯一的方法是使用真实数据进行基准测试。对性能的直觉判断经常是错误的。

import java.util.stream.LongStream;

public class Main {
    public static void main(String[] args) {
        long start = System.nanoTime();
        long sum = LongStream.rangeClosed(1, 50_000_000).parallel().sum();
        long ms = (System.nanoTime() - start) / 1_000_000;
        System.out.println("sum=" + sum + " took ~" + ms + "ms");
    }
}

实用检查清单

只有在以下条件全部满足时，才优先使用并行：

  • N 较大，和/或每个元素的工作量很大。
  • 数据源可拆分（数组、ArrayList、范围）。
  • 合并成本低且满足结合律。
  • 任务受 CPU 限制，且不包含阻塞式输入输出。
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        double avg = IntStream.rangeClosed(1, 10_000_000)
            .parallel()
            .mapToDouble(Math::sqrt)
            .average()
            .getAsDouble();
        System.out.println(avg);
    }
}

快速检查

哪种情形最适合使用并行流？

回顾

您了解了并行执行何时有帮助：

  • 收益会随着 N x Q 增大而增加（数据规模乘以每个元素的成本）。
  • 需要可拆分的数据源（数组、ArrayList、范围）。
  • 需要低成本且满足结合律的合并操作。
  • 让任务保持受 CPU 限制，避免阻塞式输入输出，并始终进行测量。

常见问题解答

「并行何时有帮助」课时是免费的吗？

是的 — 「并行何时有帮助」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Java Academy 课程的其余内容，请升级到 CoddyKit PRO。 Java Academy 课程共包含 4 节课。

「并行何时有帮助」这节课中我会学到什么？

工作负载与数据规模因素 你通过在浏览器中直接运行的动手代码来练习 Java Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Java Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Java Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 2 节课，共 4 节。

「并行何时有帮助」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Java Academy 课中编写并运行代码吗？

能。每节 Java Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

  1. 创建并行流
  2. 并行何时有帮助
  3. 线程安全与副作用
  4. 常见陷阱
← 返回 Java Academy