定义

用于遍历和分割“源”元素的对象。

数据源

Spliterator的元素来源可能是一个数组，一个集合，一个IO通道，一个生成函数。

处理数据源的方式

Spliterator可以单独或顺序地批量地遍历元素。

Spliterator也可以将其部分元素作为另一个Spliterator进行分区，为了并行化操作。使用不能拆分或以非常不平衡或低效的方式进行拆分Spliterator的操作不太可能从并行中获益。遍历和分解流出的元素;每个Spliterator只对单个批量计算有用。

特征 characteristics

Spliterator 还声明了 一组关于它的结构和源的特征(characteristics)，包含以下以下几种：

ORDERED int 型 值为16 既定的顺序，Spliterator保证拆分和遍历时是按照这一顺序。

DISTINCT int型 值为1 表示元素都不是重复的，对于每一对元素{ x, y}，{ !x.equals(y)}。例如，这适用于基于{@link Set}的Spliterator。

SORTED int型 值为4 表示元素顺序按照预定义的顺序，可以通过getComparator 获取排序器，若返回null ,则是按自然排序。

SIZED int型 值为64 表示在遍历分隔之前 estimateSize() 返回的值代表一个有限的大小，在没有修改结构源的情况下，代表了一个完整遍历时所遇到的元素数量的精确计数。

NONNULL init型 值为256 表示数据源保证元素不会为空

IMMUTABLE int 型 值为1024 表示在遍历的过程中不能添加、替换、删除元素

CONCURRENT int型 值为4096 表示元素可以被多个线程安全并发得修改而不需要外部的同步。

SUBSIZED int型 值为16384 表示trySplit()返回的结果都是SIZED和SUBSIZED

Tips

一个late-binding Spliterator 在第一次遍历、分隔或者查询任何估计的大小时绑定 ，而不是在创建的时候绑定。

非后期绑定的Spliterator在构建或在任何方法的第一次调用时绑定到数据源。在绑定之前对源进行的修改将在遍历Spliterator时反映出来，在绑定源之后，发现 structural interference应立即抛出ConcurrentModificationException 异常，这称为快速失败。

Spliterator的批量遍历方法({@link # forEachRemaining()})可以在遍历完所有元素之后优化遍历并检查 structural interference，而不是检查每个元素并立即失败。

Spliterator 提供估计剩余多少元素的方法，即estimateSize()方法,理想情况下，正如在characteristics SIZED反应的那样，这个值会与成功遍历所遇到的数量完全一致。但是，即使不知道确切的值，估计值对于在数据源上执行的操作来说仍然是有用的，例如帮助确定是进一步分割还是按顺序遍历其余的元素。

并行的实现

尽管在并行算法中有明显的实用功能，但spliterator并不向我们期望的那样是线程安全的;相反，使用spliterator的并行算法的实现应该确保spliterator一次只使用一个线程。这个通常很容易通过 串行线程封闭 来实现:通常使用递归分解这个经典的并行算法。调用{@link #trySplit()}的线程可以将返回的Spliterator传递给另一个线程，而这个线程又可以遍历或进一步拆分这个Spliterator。如果两个或多个线程在同一个Spliterator上同时操作，则不定义分割和遍历的行为。如果原始线程将一个spliterator传递给另一个线程进行处理，那么最好是在使用{@link #tryAdvance(Consumer) tryAdvance()}的任何元素之前进行切换，因为某些保证(例如{@link #estimateSize()}对于{@code size}spliterator的精度)只有在遍历开始之前才有效。

Spliterator分割图.png

Spliterator通过支持分割和单元素迭代，除了支持串行遍历，还支持高效的并行遍历。另外，Spliterator 不像Iterator设计的那样设计两个方法hasNext 判断是否有元素和next() 返回元素进行消费，Spliterator 设计一个tryAdvance方法，消费元素，如果有就消费并返回true，如果没有则返回false，不需要两个独立的方法。

对于可变源，如果在Spliterator绑定到其数据源和遍历结束之间对源进行结构上的干扰(添加、替换或删除元素)，可能会出现随机和不确定的影响。

对于structurally interfered 可以有一下几个方法避免：

数据源为java.util包的CopyOnWriteArrayList ，它是不可变的，数据源为该类实例的Spliterator同样会将characteristics声明为IMMUTABLE

数据源为java.util包的ConcurrentHashMap, 数据源为该类实例的Spliterator会将特性(characteristics) 声明为CONCURRENT。

可变的数据源会提供一个 late-binding 和快速失败的Spliterator。

这里有一个类(除了当做例子之外，它不是一个非常有用的类)，它维护一个数组，其中实际数据保存在偶数位置，而不相关的标记数据保存在奇数位置。它的Spliterator会忽略标记数据。

/**

* @Author unyielding

* @date 2018/7/26 0026 19:48

* @desc 一个类(除了当做例子之外，它不是一个非常有用的类)，

* 它维护一个数组， 其中实际数据保存在偶数位置，而不相关的标记数据保存在奇数位置。

* 它的Spliterator会忽略标记数据。

*/

public class TaggedArray {

private final Object[] elements;//创建后，不可变的

/**

* 构造方法

*

* @param data 实际数据

* @param tags 标记数据

*/

TaggedArray(T[] data, Object[] tags) {

int size = data.length;

//保证实际数据数组和标记数据数组的大小相同

if (tags.length != size) throw new IllegalArgumentException();

this.elements = new Object[2 * size];

//初始化elements 数组

for (int i = 0, j = 0; i < size; ++i) {

elements[j++] = data[i];

elements[j++] = tags[i];

}

}

public Spliterator spliterator() {

return new TaggedArraySpliterator<>(elements, 0, elements.length);

}

static class TaggedArraySpliterator implements Spliterator {

private final Object[] array;

private int origin; //当前索引，在分割或者遍历时使用

private final int fence;//最大的下标加一

TaggedArraySpliterator(Object[] array, int origin, int fence) {

this.array = array;

this.origin = origin;

this.fence = fence;

}

/**

* 批量遍历

* @param action 消费函数 {@link Consumer} 的子类，可以通过lambda表达式表示

*/

@Override

public void forEachRemaining(Consumer super T> action) {

for (; origin < fence; origin += 2) {

action.accept((T) array[origin]);

}

}

/**

* 处理单个元素

* @param action 消费函数 {@link Consumer} 的子类，可以通过lambda表达式表示

* @return 如果有元素消费就返回true,如果没有就直接返回false

*/

@Override

public boolean tryAdvance(Consumer super T> action) {

if (origin < fence) {

action.accept((T) array[origin]);

origin += 2;

return true;

}

return false;

}

/**

* 分割数据源

* @return 返回分割后生成的Spliterator

*/

@Override

public Spliterator trySplit() {

int lo = origin;

int mid = ((lo + fence) >> 1) & 1;//强制中点数为偶数

if (lo < mid) {

origin = mid;//重置Spliterator的 当前下标

return new TaggedArraySpliterator<>(array, lo, mid);

}//太小不需要拆分

return null;

}

/**

* 估计剩余还有多少元素

* @return 剩余还有多少元素

*/

@Override

public long estimateSize() {

return (long) ((fence - origin) / 2);

}

/**

* 获取特征值 用户可以根据 特征值 ，

* 用户可以根据 配置更好的控制和优化它的使用

* @return

*/

@Override

public int characteristics() {

return ORDERED | IMMUTABLE | SIZED | SUBSIZED;

}

}

/**

* 并行遍历

* @param a 一个{@link TaggedArray} 实例

* @param action

* @param 每个元素的值

*/

static void parEach(TaggedArray a, Consumer action) {

Spliterator spliterator = a.spliterator();

long targetBatchSize = spliterator.estimateSize()

/ (ForkJoinPool.getCommonPoolParallelism() * 8);

new ParEach<>(null, spliterator, action, targetBatchSize).invoke();

}

}

并行计算器 ，其实就是继承CountedCompleter 一个可以放到forlk/join 线程池里的类

/**

* 并行计算器

* @param 元素的类型

*/

static class ParEach extends CountedCompleter {

final Spliterator spliterator;

final Consumer action;

final long targetBatchSize;

ParEach(ParEach parent, Spliterator spliterator,

Consumer action, long targetBatchSize) {

super(parent);

this.spliterator = spliterator;

this.action = action;

this.targetBatchSize = targetBatchSize;

}

@Override

public void compute() {

Spliterator sub;

while (spliterator.estimateSize() > targetBatchSize

&& (sub = spliterator.trySplit()) != null) {

addToPendingCount(1);

new ParEach<>(this, sub, action, targetBatchSize).fork();

}

spliterator.forEachRemaining(action);

propagateCompletion();

}

}