这是不可变链表的经典实现:
public abstract class List<A> implements Iterable<A> {
private static final List NIL = new Nil();
public abstract A head();
public abstract List<A> tail();
public List<A> cons(A a) { return new Cons<>(a, this); }
public static <A> List<A> nil() { return NIL; }
@Override
public Iterator<A> iterator() {
return new Iterator<A>() {
private List<A> list = List.this;
@Override
public boolean hasNext() {
return list != NIL;
}
@Override
public A next() {
A n = list.head();
list = list.tail();
return n;
}
};
}
public Stream<A> stream() {
return StreamSupport.stream(spliterator(), false);
}
public Stream<A> parallelStream() {
return StreamSupport.stream(spliterator(), true);
}
}
class Nil extends List {
@Override public Object head() { throw new NoSuchElementException(); }
@Override public List tail() { throw new NoSuchElementException(); }
}
class Cons<A> extends List<A> {
private final A head;
private final List<A> tail;
Cons(A head, List<A> tail) {
this.head = head;
this.tail = tail;
}
@Override public A head() { return head; }
@Override public List<A> tail() { return tail; }
}
spliterator()
的默认实现不支持高效的并行化:
List<Integer> list = List.<Integer> nil().cons(3).cons(2).cons(1);
list.parallelStream().forEach(i -> {
System.out.println(i);
try {
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
});
这将按顺序打印1, 2, 3
。
如何实施spliterator()
以支持有效的并行化?
答案 0 :(得分:3)
即使是估计的大小(这是Iterable
的默认实现)也无法报告的分裂器很难通过并行管道进行分割。如果您跟踪List
的大小,则可以解决此问题。在您的情况下,跟踪确切的大小并不是很难:
public abstract class List<A> implements Iterable<A> {
...
public abstract long size();
@Override
public Spliterator<A> spliterator() {
return Spliterators.spliterator(iterator(), size(), Spliterator.ORDERED);
}
}
class Nil extends List {
...
public long size() {
return 0;
}
}
class Cons<A> extends List<A> {
...
private final long size;
Cons(A head, List<A> tail) {
this.head = head;
this.tail = tail;
this.size = tail.size()+1;
}
...
@Override
public long size() {
return size;
}
}
之后并行化会更好。请注意,它仍然是穷人并行化,因为你无法快速跳转到列表的中间位置,但在很多情况下它会提供合理的加速。
另请注意,明确指定Spliterator.ORDERED
特征会更好。否则,即使明确请求(例如,通过forEachOrdered()
终端操作),也可以在并行流操作中忽略该顺序。
答案 1 :(得分:1)
您可以使用一些算法与交错 - 例如,计算元素并在整数除法后使用余数。这可以拆分并行迭代的元素。
您甚至可以在构造迭代器之前迭代一次,将列表拆分为 interval ,但这会超过流的目的 - 例如如果你将它用于anyMatch
,它会减慢你的速度。
没有真正有效的分割链表的方法(在不到线性的时间内),除非您创建自己的链接列表实现,其中包含一些额外的信息。
编辑哦等等 - 您只实施Iterable
。这是非常有限的,你必须提出一个只有一次通过的算法。这意味着,拆分本身根本不会是并行的,所以你不妨在这个过程的其他地方强制执行你的并行性。