使用fork-join的Java多路树搜索

我有多路径树结构，我必须遍历它来确定状态。我正在研究“Post-Order”类型的遍历，其中首先处理叶节点。搜索结束条件取决于处于非活动状态的任何子节点。另外，从性能角度来看，我希望使用JDK7的fork-join机制

这里是一个（非常）粗略的草图，说明了你如何做到这一点

final class TreeNode {
    private final Iterable<TreeNode> children;

    TreeNode(Iterable<TreeNode> aChildren) {
        children = aChildren;
    }

    Iterable<TreeNode> getChildren() {
        return children;
    }

    void postorder(TreeNodeIterator iterator) {
        postorderTraverse(this, iterator);
    }

    private void postorderTraverse(TreeNode node, TreeNodeIterator iterator) {
        for (TreeNode child : children) {
            postorderTraverse(child, iterator);
        }
        iterator.visit(node);
    }

    void postorderParallel(TreeNodeIterator iterator) {
        new ForkJoinPool().invoke(new VisitNodeAction(iterator, this));
    }

    interface TreeNodeIterator {
        void visit(TreeNode child);
    }

    private class VisitNodeAction extends RecursiveAction {
        private final TreeNodeIterator iterator;
        private final TreeNode node;

        private VisitNodeAction(TreeNodeIterator iterator, TreeNode node) {
            this.iterator = iterator;
            this.node = node;
        }

        @Override
        protected void compute() {
            List<RecursiveAction> tasks = new LinkedList<RecursiveAction>();
            for (TreeNode child : children) {
                tasks.add(new VisitNodeAction(iterator, child));
            }
            invokeAll(tasks);
            iterator.visit(node);
        }
    }
}

final class树节点{
私生子；
TreeNode（Iterable aChildren）{
儿童=儿童；
}
Iterable getChildren（）{
返回儿童；
}
无效后序（TreeNodeIterator迭代器）{
postorderTraverse（这是迭代器）；
}
私有void postorderTraverse（TreeNode节点，TreeNode迭代器）{
for（TreeNode儿童：儿童）{
postorderTraverse（子级、迭代器）；
}
迭代器访问（节点）；
}
void postorderParallel（TreeNodeIterator迭代器）{
new ForkJoinPool（）.invoke（new VisitNodeAction（迭代器，this））；
}
接口树转换器{
无效访问（TreeNode儿童）；
}
私有类VisitNodeAction扩展了RecursiveAction{
私有最终树迭代器；
私有最终树节点；
private VisitNodeAction（TreeNode迭代器、TreeNode节点）{
this.iterator=迭代器；
this.node=节点；
}
@凌驾
受保护的void compute（）{
列表任务=新建LinkedList（）；
for（TreeNode儿童：儿童）{
添加（新的VisitNodeAction（迭代器、子对象））；
}
调用所有（任务）；
迭代器访问（节点）；
}
}
}

一些需要修改的内容：

• 正在添加状态为“非活动”的支票。最简单的方法是在每个

  RecursiveAction

  中保留一个原子布尔值，该布尔值在处理节点之前进行检查，并在节点处于非活动状态时进行更新，尽管这不是一个非常干净或实用的路由
• 通过添加一种确定何时应使用新线程的方法，上述方法为每个节点使用一个线程。此外，您还可以通过在每次调用

  postorderParallel

  时不创建

  ForkJoinPool

  来对其进行一些优化