Java並列ストリーム-parallel（）メソッドを呼び出す順序[終了]

AtomicInteger recordNumber = new AtomicInteger();
Files.lines(inputFile.toPath(), StandardCharsets.UTF_8)
     .map(record -> new Record(recordNumber.incrementAndGet(), record)) 
     .parallel()           
     .filter(record -> doSomeOperation())
     .findFirst()

これを書いたとき、並列はマップの後に配置されるため、スレッドはマップ呼び出しのみで生成されると想定しました。しかし、ファイルのいくつかの行は、実行ごとに異なるレコード番号を取得していました。

公式のJavaストリームドキュメントといくつかのWebサイトを読んで、ストリームが内部でどのように機能するかを理解しました。

いくつかの質問：

• Java並列ストリームは、ArrayList、LinkedListなどのすべてのコレクションによって実装されるSplitIteratorに基づいて機能します。これらのコレクションから並列ストリームを構築する場合、対応する分割イテレータを使用して、コレクションを分割および反復します。これは、マップの結果（つまり、レコードポジョ）ではなく、元の入力ソース（ファイル行）レベルで並列処理が発生した理由を説明しています。私の理解は正しいですか？

• 私の場合、入力はファイルIOストリームです。使用される分割イテレーターはどれですか？

• parallel()パイプラインのどこに配置してもかまいません。元の入力ソースは常に分割され、残りの中間操作が適用されます。

  この場合、Javaは、ユーザーが元のソース以外のパイプラインの任意の場所に並列操作を配置できないようにする必要があります。それは、Javaストリームが内部でどのように機能するかを知らない人たちに間違った理解を与えているからです。私が知っているparallel()操作はStreamオブジェクトタイプのために、それがこのように働いている、ように定義されていたであろう。ただし、代替ソリューションを提供することをお勧めします。

• 上記のコードスニペットでは、入力ファイルのすべてのレコードに行番号を追加しようとしているので、順序付けする必要があります。ただし、doSomeOperation()ヘビーウェイトのロジックなので並行して適用したい。達成する1つの方法は、独自にカスタマイズした分割イテレーターを作成することです。他に方法はありますか？

これは、マップの結果（レコードポジョ）ではなく、元の入力ソース（ファイル行）レベルで並列処理が発生した理由を説明しています。

ストリーム全体は並列または順次です。順次または並列に実行する操作のサブセットは選択しません。

端末操作が開始されると、ストリームパイプラインは、それが呼び出されるストリームの方向に応じて、順次または並列に実行されます。[...]端末操作が開始されると、呼び出されたストリームのモードに応じて、ストリームパイプラインが順次または並列に実行されます。同じソース

ご指摘のとおり、並列ストリームは分割イテレータを使用します。明らかに、これは操作が実行を開始する前にデータを分割することです。

私の場合、入力はファイルIOストリームです。使用される分割イテレーターはどれですか？

ソースを見ると、 java.nio.file.FileChannelLinesSpliterator

パイプラインのどこにparallel（）を配置してもかまいません。元の入力ソースは常に分割され、残りの中間操作が適用されます。

正しい。あなたも呼び出すことができますparallel()し、sequential()複数回。最後に呼び出された方が勝ちます。を呼び出すとparallel()、返されるストリームにそれを設定します。前述のとおり、すべての操作は順次または並列に実行されます。

この場合、Javaは、ユーザーが元のソース以外のパイプラインのどこにでも並列操作を配置できないようにする必要があります...

これは意見の問題になります。ZabuzaはJDKデザイナーの選択をサポートする正当な理由を与えていると思います。

達成する1つの方法は、独自にカスタマイズした分割イテレーターを作成することです。他に方法はありますか？

これはオペレーションによって異なります

• 場合はfindFirst()、あなたの本当の端末操作であると多くの呼び出しがありませんので、その後、あなたも、並列実行を心配する必要はありませんdoSomething()とにかく（findFirst()短絡です）。.parallel()実際には、複数の要素が処理される可能性がありますがfindFirst()、シーケンシャルストリームでは処理されません。

• 端末操作で多くのデータが作成されない場合はRecord、シーケンシャルストリームを使用してオブジェクトを作成し、結果を並列処理することができます。

  List<Record> smallData = Files.lines(inputFile.toPath(), 
                                       StandardCharsets.UTF_8)
    .map(record -> new Record(recordNumber.incrementAndGet(), record)) 
    .collect(Collectors.toList())
    .parallelStream()     
    .filter(record -> doSomeOperation())
    .collect(Collectors.toList());
  

• パイプラインがメモリに大量のデータをロードする場合（これがを使用している理由である可能性がありますFiles.lines()）、おそらくカスタムの分割反復子が必要になります。ただし、そこに行く前に、他のオプションを検討します（最初にid列を使用して行を保存するなど、それは私の意見です）。
  次のように、レコードを小さいバッチで処理することも試みます。

  AtomicInteger recordNumber = new AtomicInteger();
  final int batchSize = 10;
  
  try(BufferedReader reader = Files.newBufferedReader(inputFile.toPath(), 
          StandardCharsets.UTF_8);) {
      Supplier<List<Record>> batchSupplier = () -> {
          List<Record> batch = new ArrayList<>();
          for (int i = 0; i < batchSize; i++) {
              String nextLine;
              try {
                  nextLine = reader.readLine();
              } catch (IOException e) {
                  //hanlde exception
                  throw new RuntimeException(e);
              }
  
              if(null == nextLine) 
                  return batch;
              batch.add(new Record(recordNumber.getAndIncrement(), nextLine));
          }
          System.out.println("next batch");
  
          return batch;
      };
  
      Stream.generate(batchSupplier)
          .takeWhile(list -> list.size() >= batchSize)
          .map(list -> list.parallelStream()
                           .filter(record -> doSomeOperation())
                           .collect(Collectors.toList()))
          .flatMap(List::stream)
          .forEach(System.out::println);
  }
  

  これはdoSomeOperation()、すべてのデータをメモリにロードせずに並行して実行されます。しかし、それbatchSizeは考えを与える必要があることに注意してください。

元のStreamデザインには、異なる並列実行設定で後続のパイプラインステージをサポートするというアイデアが含まれていましたが、このアイデアは放棄されました。APIはこの時期に由来する可能性がありますが、一方で、呼び出し側に並列実行または順次実行の明確な単一の決定を強制するAPI設計は、はるかに複雑になります。

による実際のSpliterator使用Files.lines(…)は実装に依存します。Java 8（OracleまたはOpenJDK）では、常にと同じになりBufferedReader.lines()ます。最近のJDKではPath、がデフォルトのファイルシステムに属し、文字セットがこの機能でサポートされているものの1つである場合、専用のSpliterator実装であるを取得しますjava.nio.file.FileChannelLinesSpliterator。前提条件が満たされていなくても、と同じ結果が得られますBufferedReader.lines()。これは、Iterator内に実装されBufferedReader、を介してラップされていることに基づいていますSpliterators.spliteratorUnknownSize。

特定のタスクはSpliterator、並列処理の前にソースで行番号付けを直接実行できるカスタムで処理するのが最適です。これにより、後続の並列処理が制限なしに可能になります。

public static Stream<Record> records(Path p) throws IOException {
    LineNoSpliterator sp = new LineNoSpliterator(p);
    return StreamSupport.stream(sp, false).onClose(sp);
}

private static class LineNoSpliterator implements Spliterator<Record>, Runnable {
    int chunkSize = 100;
    SeekableByteChannel channel;
    LineNumberReader reader;

    LineNoSpliterator(Path path) throws IOException {
        channel = Files.newByteChannel(path, StandardOpenOption.READ);
        reader=new LineNumberReader(Channels.newReader(channel,StandardCharsets.UTF_8));
    }

    @Override
    public void run() {
        try(Closeable c1 = reader; Closeable c2 = channel) {}
        catch(IOException ex) { throw new UncheckedIOException(ex); }
        finally { reader = null; channel = null; }
    }

    @Override
    public boolean tryAdvance(Consumer<? super Record> action) {
        try {
            String line = reader.readLine();
            if(line == null) return false;
            action.accept(new Record(reader.getLineNumber(), line));
            return true;
        } catch (IOException ex) {
            throw new UncheckedIOException(ex);
        }
    }

    @Override
    public Spliterator<Record> trySplit() {
        Record[] chunks = new Record[chunkSize];
        int read;
        for(read = 0; read < chunks.length; read++) {
            int pos = read;
            if(!tryAdvance(r -> chunks[pos] = r)) break;
        }
        return Spliterators.spliterator(chunks, 0, read, characteristics());
    }

    @Override
    public long estimateSize() {
        try {
            return (channel.size() - channel.position()) / 60;
        } catch (IOException ex) {
            return 0;
        }
    }

    @Override
    public int characteristics() {
        return ORDERED | NONNULL | DISTINCT;
    }
}

そして、以下は、並列の適用が適用される場合の簡単なデモです。peekの出力は、2つの例の違いを明確に示しています。注：map呼び出しは、の前に別のメソッドを追加するために投げられparallelます。

IntStream.rangeClosed (1,20).peek(a->System.out.print(a+" "))
        .map(a->a + 200).sum();
System.out.println();
IntStream.rangeClosed(1,20).peek(a->System.out.print(a+" "))
        .map(a->a + 200).parallel().sum();