Question

我正在努力寻找一种从这个流中获得加速的正确方法：

    StreamSupport.stream(new BinaryTreeSpliterator(root), true)
                .parallel()
                .map(node -> processor.onerousFunction(node.getValue()))
                .mapToInt(i -> i.intValue())
                .sum()

onerousFunction()只是一个使线程工作一点并返回节点的int值的函数。

无论我使用多少cpus，执行时间总是保持不变。我认为问题出现在我写的Spliterator中：

    public class BinaryTreeSpliterator extends AbstractSpliterator<Node> {

        private LinkedBlockingQueue<Node> nodes = new LinkedBlockingQueue<>();

        public BinaryTreeSpliterator(Node root) {
            super(Long.MAX_VALUE, NONNULL | IMMUTABLE);
            this.nodes.add(root);
        }

        @Override
         public boolean tryAdvance(Consumer<? super Node> action) {
            Node current = this.nodes.poll();
            if(current != null) {
                action.accept(current);
                if(current.getLeft() != null) 
                    this.nodes.offer(current.getLeft());
                if(current.getRight() != null)
                    this.nodes.offer(current.getRight());
                return true;
            }
            return false;
        }

    }

但我真的无法找到一个好的解决方案。

Answer 1

要并行处理数据，您需要trySplit实现将部分数据作为新的Spliterator实例返回。每个单个线程遍历spliterator实例。因此，顺便提一下，你的分词器中不需要线程安全集合。但是你的问题是你继承了来自trySplit的{{1}}实现，它试图提供一些并行支持，尽管你对数据一无所知。

它通过顺序请求一些项目，将它们缓冲到一个数组并返回一个新的基于数组的spliterator来实现。不幸的是，它不能很好地处理“未知大小”（这同样适用于一般的并行流实现）。默认情况下它会缓冲1024个元素，如果有多少元素，下次会缓冲更多。更糟糕的是，流实现不会使用基于数组的spliterator的良好分割功能，因为它像文字AbstractSpliterator一样处理“未知大小”，结论是你的分裂器具有比数组中1024个元素多得多的元素，因此，甚至不会尝试拆分基于数组的分裂器。

您的分词器可以实现更合适的Long.MAX_VALUE方法：

trySplit

请注意，此分词符也可以作为public class BinaryTreeSpliterator extends AbstractSpliterator<Node> { /** * a node that has not been traversed, but its children are only * traversed if contained in this.pending * (otherwise a different spliterator might be responsible) */ private Node pendingNode; /** pending nodes needing full traversal */ private ArrayDeque<Node> pending = new ArrayDeque<>(); public BinaryTreeSpliterator(Node root) { super(Long.MAX_VALUE, NONNULL | IMMUTABLE); push(root); } private BinaryTreeSpliterator(Node pending, Node next) { super(Long.MAX_VALUE, NONNULL | IMMUTABLE); pendingNode = pending; if(next!=null) this.pending.offer(next); } private void push(Node n) { if(pendingNode == null) { pendingNode = n; if(n != null) { if(n.getRight()!=null) pending.offerFirst(n.getRight()); if(n.getLeft() !=null) pending.offerFirst(n.getLeft()); } } else pending.offerFirst(n); } @Override public boolean tryAdvance(Consumer<? super Node> action) { Node current = pendingNode; if(current == null) { current = pending.poll(); if(current == null) return false; push(current.getRight()); push(current.getLeft()); } else pendingNode = null; action.accept(current); return true; } @Override public void forEachRemaining(Consumer<? super Node> action) { Node current = pendingNode; if(current != null) { pendingNode = null; action.accept(current); } for(;;) { current = pending.poll(); if(current == null) break; traverseLocal(action, current); } } private void traverseLocal(Consumer<? super Node> action, Node current) { do { action.accept(current); Node child = current.getLeft(); if(child!=null) traverseLocal(action, child); current = current.getRight(); } while(current != null); } @Override public Spliterator<Node> trySplit() { Node next = pending.poll(); if(next == null) return null; if(pending.isEmpty()) { pending.offer(next); next = null; } if(pendingNode==null) return next==null? null: new BinaryTreeSpliterator(next); Spliterator<Node> s = new BinaryTreeSpliterator(pendingNode, next); pendingNode = null; return s; } }分词符，符合左上角的顺序。完全无序的分裂器可以稍微简单一些。

您可以实现比继承默认值更高效的ORDERED方法，例如

forEachRemaining

但是如果您的应用程序必须处理不平衡的树（特别是此示例中的非常长的左侧路径），此方法可能会导致堆栈溢出错误。

Java并行流：有一种导航二叉树的方法吗？

1 个答案: