流并行跳过-链式流方法的顺序有什么区别吗？

Question

stream.parallel().skip(1) 

vs

stream.skip(1).parallel() 

这是关于Java8流的
这两个都跳过了第一行/条目吗？

例如：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.StringReader;
import java.util.concurrent.atomic.AtomicLong;

public class Test010 {

    public static void main(String[] args) {
        String message = 
        "a,b,c\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n1,2,3\n4,5,6\n7,8,9\n";

        try(BufferedReader br = new BufferedReader(new StringReader(message))){

            AtomicLong cnt = new AtomicLong(1);

            br.lines().parallel().skip(1).forEach(
                s -> {
                    System.out.println(cnt.getAndIncrement() + "->" + s);
                }
            );

        }catch (IOException e) {
            e.printStackTrace();
        }

    }

}

今天早些时候，我有时会在lambda表达式中得到标题行“a，b，c”。这是一个惊喜，因为我本以为已经跳过了。现在我不能让这个例子工作，也就是说，我不能得到lambda表达式中的头行。所以我现在很困惑，也许是其他因素影响了这种行为。当然，这只是一个例子。在现实世界中，消息是从CSV文件读取的。该消息是该CSV文件的完整内容。

Answer 1

是的，但是skip（n）较慢，因为n在并行流中更大。

下面是kip（）中的API注释：

虽然skip（）通常是顺序流管道上的一种廉价操作，但在有序并行管道上，它可能非常昂贵，尤其是对于大值的n，因为skip（n）被约束为不仅跳过任何n元素，而且跳过相遇顺序中的第一个n元素。使用无序流源（例如generate（Supplier））或使用BaseStream删除订购约束。无序（）可能会导致并行管道中的skip（）显著加速，如果情况的语义允许的话。如果需要与遭遇顺序保持一致，并且在并行管道中使用skip（）时，您的性能或内存利用率较差，请切换到使用BaseStream的顺序执行。sequential（）可以提高性能。

因此，从本质上讲，如果您希望使用skip（）获得更好的性能，请不要使用并行流或无序流。

至于它似乎不适用于并行流，也许你真的看到元素不再有序了？例如，此代码的输出：

Stream.of("Hello", "How", "Are", "You?")
    .parallel()
    .skip(1)
    .forEach(System.out::println);

是

你呢<怎么做

创意演示

这很好，因为在并行流中，forEach不会强制执行遭遇顺序。如果你想让它强制执行遭遇顺序，可以使用顺序流（或者使用forEachOrdered，这样你的意图就显而易见了）。

Stream.of("Hello", "How", "Are", "You?")
    .skip(1)
    .forEachOrdered(System.out::println);

你怎么样？

Answer 2

实际上，一个问题中有两个问题，第一个问题是它是否会对编写流产生影响。parallel（）。跳过（1）或流。跳过（1）。parallel（），第二个是其中一个或两个元素是否总是跳过第一个元素。另见“加载问题”。

第一个答案是没有区别，因为指定。sequential（）或。parallel（）。

因此，在任何一种情况下，您都请求并行执行，这可能会影响跳过操作的结果，这是第二个问题的主题。

答案并不那么简单。如果流首先没有定义的相遇顺序，任意元素可能会被跳过，这是因为没有“第一”元素，即使在迭代源时可能会有一个元素首先遇到。

如果您有一个有序的流，skip（1）应该跳过第一个元素，但这是最近才提出的。如“Stream.skip behavior with unordered terminal operation”（无序终端操作的Stream.skip behavior）中所述，链接无序终端操作会对早期实现中的skip操作产生影响，这是否可能是有意的，存在一些不确定性，正如“这是Files.lines（）中的一个bug，还是我对并行流有误解？”中所示，恰好与你的代码很接近；显然，跳过第一行是常见的情况。

最后一句话是，早期JRE的行为是一个错误，有序流上的kip（1）应该跳过第一个元素，即使流管道是并行执行的，终端操作是无序的。相关的错误报告将jdk1.8.0_60命名为第一个固定版本，我可以验证。因此，如果您在较旧的实现上使用，您可能会在使用时遇到Stream跳过不同的元素。并行（）和无序的. foreach（...）终端操作。如果实现偶尔跳过预期的元素，这并不矛盾，这就是多线程的不可预测性。

所以答案仍然是流。parallel（）。跳过（1）和流。跳过（1）。parallel（）具有相同的行为，即使在早期版本中使用时也是如此，因为当与无序的终端操作（如forEach）一起使用时，这两种行为同样不可预测。它们应始终跳过具有有序流的第一个元素，当与1.8.0_60或更新版本一起使用时，它们会跳过。