0Pricing
Java Academy · 课时

线程安全与副作用

避免共享可变状态

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

并行意味着并发访问

在并行流中，多个线程会同时运行您的匿名函数。它们访问的任何共享可变状态都会造成竞态条件。

import java.util.stream.IntStream;

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

危险：修改共享变量

被多个线程访问的普通 int 计数器会丢失更新。绝不要在 forEach 中将结果累积到共享可变状态中。

import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        AtomicInteger counter = new AtomicInteger();
        IntStream.rangeClosed(1, 1000).parallel()
            .forEach(n -> counter.incrementAndGet());
        System.out.println(counter.get());
    }
}

普通集合为何会出问题

在并行 forEach 中向非线程安全的 ArrayList 添加元素，可能会损坏集合或丢失元素。正确的解决方法是完全不要共享并修改状态。

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        List<Integer> result = IntStream.rangeClosed(1, 10).parallel()
            .boxed()
            .collect(Collectors.toList());
        System.out.println(result.size());
    }
}

正确的工具：collect

请使用 collect，而不是产生副作用的 forEach。收集器框架会安全地为每个线程累积部分容器，然后将它们合并。

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        List<Integer> squares = IntStream.rangeClosed(1, 6).parallel()
            .map(n -> n * n)
            .boxed()
            .collect(Collectors.toList());
        System.out.println(squares);
    }
}

正确的工具：reduce

当操作满足结合律且无状态时，reduce 天然是线程安全的，因为它会合并部分结果，而不会共享可变状态。

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int sum = IntStream.rangeClosed(1, 1000).parallel()
            .reduce(0, Integer::sum);
        System.out.println(sum);
    }
}

无状态匿名函数

流中的匿名函数应该是无状态的：其结果只取决于输入，而不依赖外部可变变量或之前的元素。

import java.util.stream.IntStream;

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

使用原子类型作为替代方案

如果确实必须共享计数器，请使用 AtomicLong 这类原子类。它们可以正确地串行化更新，但会增加竞争。

import java.util.concurrent.atomic.AtomicLong;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        AtomicLong sum = new AtomicLong();
        IntStream.rangeClosed(1, 1000).parallel()
            .forEach(sum::addAndGet);
        System.out.println(sum.get());
    }
}

并发集合

如果需要在线程之间共享映射，ConcurrentHashMap 是安全的。不过，在可行时仍应优先使用 Collectors.groupingByConcurrent。

import java.util.Map;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> words = List.of("a", "bb", "cc", "ddd");
        Map<Integer, List<String>> byLen = words.parallelStream()
            .collect(Collectors.groupingByConcurrent(String::length));
        System.out.println(byLen);
    }
}

避免依赖顺序的逻辑

不要在并行匿名函数中依赖遇到顺序。假设按顺序处理的操作在并行执行时会产生错误结果。

import java.util.stream.IntStream;

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

纯函数可以安全地并行化

黄金法则是：编写纯的、无状态的、不会相互干扰的操作。这样，无论流是顺序执行还是并行执行，都能得到一致且正确的结果。

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> in = List.of("red", "green", "blue");
        String out = in.parallelStream()
            .map(String::toUpperCase)
            .sorted()
            .collect(Collectors.joining(","));
        System.out.println(out);
    }
}

互不干扰

流运行期间，不要修改流所遍历的源集合。无论顺序执行还是并行执行，这都会导致 ConcurrentModificationException 或未定义行为。

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> src = List.of(1, 2, 3, 4);
        List<Integer> doubled = src.parallelStream()
            .map(n -> n * 2)
            .collect(Collectors.toList());
        System.out.println(doubled);
    }
}

快速检查

从并行流中累积结果的推荐方式是什么？

回顾

您保证了并行流的正确性：

  • 并行匿名函数中的共享可变状态会造成竞态。
  • 优先使用 collect 和 reduce，而不是产生副作用的 forEach。
  • 让匿名函数保持无状态、纯净且互不干扰。
  • 如果必须共享，请使用原子类型或并发集合，但这应当是最后的选择。

常见问题解答

「线程安全与副作用」课时是免费的吗？

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

「线程安全与副作用」这节课中我会学到什么？

避免共享可变状态 你通过在浏览器中直接运行的动手代码来练习 Java Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Java Academy 需要有经验吗？

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

「线程安全与副作用」课时需要多长时间？

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

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

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

此课程中的所有课时

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