java stream 并发

并发的一个Sream

static void parallelismSum(int n){
        int res = Stream.iterate(1, i -> i+1)
                .limit(n)
                .parallel()
                .reduce(0, Integer::sum);
        System.out.println("parallelismSum res: " + res);
    }

想象中上面的代码会像下面的图一样执行。但实际上不会。因为iterate函数不支持在stream开始的时候获取全部元素。
后一个元素要依赖第一个元素，所以不能在stream开始前获取全部元素
range或者rangeClose函数就可以真正地并发。因为它可以方便的分割0到n的数组。

static void rangeSum(int n){
        int res = IntStream.rangeClosed(0, n).parallel().reduce(0, Integer::sum);
        System.out.println("RangeSum res: " + res);
    }

算出一段话有几个单词
1.状态类

class WordCount{
    private final int count;
    private final boolean lastWhitespace;

    WordCount(int count, boolean lastWhitespace){
        this.count = count;
        this.lastWhitespace = lastWhitespace;
    }

    public WordCount compute(Character c){
        if(Character.isWhitespace(c)){
            return lastWhitespace? this: new WordCount(count, true);
        }else{
            return lastWhitespace? new WordCount(count+1, false): this;
        }
    }

    public WordCount combine(WordCount wordCount){
        return new WordCount(count + wordCount.getCount(), lastWhitespace);
    }

    public int getCount(){
        return count;
    }
}

2.分割器

public class MySpliterator implements Spliterator<Character> {

    private final String article;
    private int currentIndex;

    private static final int THRESHOLD = 30;

    MySpliterator(final String article){
        this.article = article;
        this.currentIndex = 0;
    }

    @Override
    public boolean tryAdvance(Consumer<? super Character> action) {
        action.accept(article.charAt(currentIndex));
        currentIndex++;
        return currentIndex < article.length();
    }

    @Override
    public Spliterator<Character> trySplit() {
        int currentSize = article.length() - currentIndex;
        if(currentSize <= THRESHOLD){
            return null;
        }
        for(int midIndex = currentSize/2 + currentIndex; midIndex < article.length();
            midIndex++){
            if(!Character.isWhitespace(article.charAt(midIndex))){
                continue;
            }
            MySpliterator mySpliterator = new MySpliterator(article.substring(currentIndex, midIndex));
            currentIndex = midIndex;
            return mySpliterator;
        }
        return null;
    }

    @Override
    public long estimateSize() {
        return article.length() - currentIndex;
    }

    @Override
    public int characteristics() {
        return ORDERED + SIZED + SUBSIZED + NONNULL + IMMUTABLE;
    }

}

3.测试用例

    public static void main(String[] args) {
        Spliterator<Character> spliterator = new MySpliterator(article);
        Stream<Character> stream =StreamSupport.stream(spliterator, true);
        WordCount wordCount = stream.reduce(new WordCount(0, true), WordCount::compute, WordCount::combine);
        System.out.println(wordCount.getCount());
    }