Java Academy · 课时

常见陷阱

Q: 「常见陷阱」这节课中我会学到什么？

顺序、装箱与通用池 你通过在浏览器中直接运行的动手代码来练习 Java Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

顺序、装箱与通用池

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

并行并不意味着免费提速

添加 parallel() 可能让代码变慢，而不是变快。本课将介绍一些典型陷阱，帮助您避免这些问题。

import java.util.stream.IntStream;

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

陷阱：顺序带来的额外开销

forEachOrdered 或 limit 这类有序操作会迫使线程之间进行协调，从而削弱并行收益。

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        IntStream.rangeClosed(1, 5).parallel()
            .forEachOrdered(System.out::println);
    }
}

unordered 可能有所帮助

如果顺序并不重要，调用 unordered() 可以让运行时跳过顺序处理，并更自由地进行并行化。

import java.util.stream.IntStream;

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

陷阱：隐藏的装箱

在并行处理中使用 Stream<Integer> 会使线程之间的装箱成本成倍增加。对于数值并行处理，请优先使用基本类型流。

import java.util.stream.IntStream;

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

陷阱：共享的公共池

所有并行流共享一个 ForkJoinPool.commonPool()。一个耗时很长的并行任务可能会耗尽同一 JVM 中其他任务的资源，包括应用程序其他部分的资源。

import java.util.concurrent.ForkJoinPool;

public class Main {
    public static void main(String[] args) {
        System.out.println(ForkJoinPool.commonPool().getParallelism());
    }
}

在自定义线程池中隔离工作

为了避免繁重的工作占用公共池，请在您自己的 ForkJoinPool 中提交并行流。

import java.util.concurrent.ForkJoinPool;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) throws Exception {
        ForkJoinPool pool = new ForkJoinPool(2);
        long sum = pool.submit(() ->
            IntStream.rangeClosed(1, 1_000_000).parallel().asLongStream().sum()
        ).get();
        pool.shutdown();
        System.out.println(sum);
    }
}

陷阱：难以拆分的数据源

LinkedList、Stream.iterate 和 BufferedReader.lines 都不易拆分。将它们并行化通常收益很小，甚至可能带来负收益。

import java.util.stream.Stream;

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

陷阱：有状态匿名函数

读取或写入外部状态的匿名函数在并行执行时会产生不确定的行为。请让它们保持无状态，以获得一致的结果。

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int sum = IntStream.rangeClosed(1, 100).parallel()
            .map(n -> n + 1)
            .sum();
        System.out.println(sum);
    }
}

陷阱：findFirst 与 findAny

findFirst 必须遵守顺序，因此在并行执行时会增加额外开销。如果任意匹配元素都可以，请使用 findAny。

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int found = IntStream.rangeClosed(1, 1_000_000).parallel()
            .filter(n -> n % 99991 == 0)
            .findAny()
            .getAsInt();
        System.out.println(found);
    }
}

陷阱：小数据上的低成本操作

对于很小的集合或开销极低的工作，拆分和合并的开销会远大于任何收益。请保持顺序执行。

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> small = List.of(1, 2, 3, 4);
        int sum = small.stream().mapToInt(Integer::intValue).sum();
        System.out.println(sum);
    }
}

陷阱：收集器中的高成本合并

包含高成本合并步骤的收集器，例如构建大型有序结构的收集器，可能会抵消并行收益。简单的累积操作可以低成本地合并。

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 -> n)
            .sum();
        System.out.println(total);
    }
}

快速检查

为什么在并行流中，findFirst 可能比 findAny 更慢？

回顾

您了解了并行执行中的常见陷阱：

顺序（forEachOrdered、limit、findFirst）会增加协调成本；在可行时使用 unordered 或 findAny。
装箱会使成本成倍增加；请优先使用基本类型流。
共享的公共池可能被耗尽；请在自定义 ForkJoinPool 中隔离繁重的工作。
难以拆分的数据源、小型数据集以及高成本的合并都会削弱并行执行的效果。

常见问题解答

「常见陷阱」课时是免费的吗？

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

「常见陷阱」这节课中我会学到什么？

顺序、装箱与通用池你通过在浏览器中直接运行的动手代码来练习 Java Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Java Academy 需要有经验吗？

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

「常见陷阱」课时需要多长时间？

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

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

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

此课程中的所有课时

← 返回 Java Academy