Java核心技术卷Ⅱ程序清单1-8

最新推荐文章于 2022-03-20 16:08:39 发布

原创最新推荐文章于 2022-03-20 16:08:39 发布 · 350 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #stream

Java核心技术卷Ⅱ（第十版）程序清单专栏收录该内容

8 篇文章

订阅专栏

本文分析了Java程序清单1-8中的parallel/ParallelStreams.java，指出在对字符串流中的短单词进行计数时，由于forEach在并发线程中运行并更新共享数组，导致每次运行计数值不同。文章探讨了这一并发问题及其潜在的解决策略。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

P36
程序清单1-8 parallel/ParallelStreams.java

代码
分析

1.代码

package parallel;

import static java.util.stream.Collectors.*;

import java.io.*;
import java.nio.charset.*;
import java.nio.file.*;
import java.util.*;
import java.util.stream.*;

public class ParallelStreams
{
   public static void main(String[] args) throws IOException
   {
      String contents = new String(Files.readAllBytes(
            Paths.get("../gutenberg/alice30.txt")), StandardCharsets.UTF_8);
      List<String> wordList = Arrays.asList(contents.split("\\PL+"));

      // Very bad code ahead
      int[] shortWords = new int[10];
      wordList.parallelStream().forEach(s -> 
         {
            if (s.length() < 10) shortWords[s.length()]++;
         });
      System.out.println(Arrays.toString(shortWords));

      // Try again--the result will likely be different (and also wrong)
      //将shortWords数组元素清为0
      Arrays.fill(shortWords, 0);
      wordList.parallelStream().forEach(s -> 
         {
            if (s.length() < 10) shortWords[s.length()]++;
         });
      System.out.println(Arrays.toString(shortWords));

      // Remedy: Group and count
      Map<Integer, Long> shortWordCounts = wordList.parallelStream()
         .filter(s -> s.length() < 10)
         .collect(groupingBy(String::length, counting()));

      System.out.println(shortWordCounts);

      // Downstream order not deterministic
      Map<Integer, List<String>> result = wordList.parallelStream().collect(
         Collectors.groupingByConcurrent(String::length));

      System.out.println(result.get(14));

      result = wordList.parallelStream().collect(
         Collectors.groupingByConcurrent(String::length));

      System.out.println(result.get(14));

      Map<Integer, Long> wordCounts = wordList.parallelStream().collect(
         groupingByConcurrent(String::length, counting()));

      System.out.println(wordCounts);
   }
}

alice30.txt：（这里仅截取一部分）

We produce about two million dollars for each hour we work.  The
fifty hours is one conservative estimate for how long it we take
to get any etext selected, entered, proofread, edited, copyright
searched and analyzed, the copyright letters written, etc.  This
projected audience is one hundred million readers.  If our value
per text is nominally estimated at one dollar then we produce $4
million dollars per hour this year as we release some eight text
files per month:  thus upping our productivity from $2 million.

2.分析

1st PART：

// Very bad code ahead
      int[] shortWords = new int[10];
      wordList.parallelStream().forEach(s -> 
         {
            if (s.length() < 10) shortWords[s.length()]++;
         });
      System.out.println(Arrays.toString(shortWords));

这里的意图是对字符串流中的所有短单词计数，但是并不能达到想要的效果，每次运行都会产生不同的计数值。
原因在于：传递给forEach的函数会在多个并发线程中运行，每个都会更新共享的数组。

如有谬误或不完善之处，恳请斧正。