public long sequentialSum(long n) {
    return Stream.iterate(1L, i -> i + 1)
        .limit(n)
        .reduce(0L, Long::sum);
}

public long iterativeSum(long n) {
    long result = 0;
    for (long i = 1L; i <= n; i++) {
        result += i;
    }
    return result;
}

public long parallelSum(long n) {
    return Stream.iterate(1L, i -> i + 1)
        .limit(n)
        .parallel()
        .reduce(0L, Long::sum);
}

stream.parallel()
    .filter(...)
    .sequential()
    .map(...)
    .parallel()
    .reduce();

@BenchmarkMode(Mode.AverageTime) // 평균 시간 측정
@OutputTimeUnit(TimeUnit.MILLISECONDS) // 밀리초 단위 출력
@Fork(2, jvmArgs={"-Xms4G", "-Xmx4G"}) // 2번 실행 (신뢰성 UP)
public class ParallelStreamBenchmark {
    private static final long N= 10_000_000L;
    @Benchmark // 벤치마크 대상 메서드 
    public long sequentialSum() {
        return Stream.iterate(1L, i -> i + 1).limit(N)
            .reduce( 0L, Long::sum);
    }
    @TearDown(Level.Invocation) // 각 벤치마크 별 가비지 컬렉터 동작 시키기 
    public void tearDown() {
        System.gc();
    }
}

for (long i = 1L; i <= n; i++) {
	result += i;
}

Stream.iterate(1L, i -> i + 1)
	.limit(n)
	.reduce(0L, Long::sum);

Stream.iterate(1L, i -> i + 1)
        .limit(n)
        .parallel()
        .reduce(0L, Long::sum);

@Benchmark
public long rangedSum() {
    return LongStream.rangeClosed(1, N)
        .reduce(0L, Long::sum);
}

@Benchmark
public long parallelRangedSum() {
    return LongStream.rangeClosed(1, N)
        .parallel()
        .reduce(0L, Long::sum);
}

public long sideEffectSum(long n) {
    Accumulator accumulator = new Accumulator();
    LongStream.rangeClosed(1, n).parallel().forEach(accumulator::add);
    return accumulator.total;
}

public class Accumulator {
    public long total = 0;
    public void add(long value) { total += value; }
}

System.out.println(sideEffectSum(10_000_000L)); // 코드 실행시 결과 500000500000이 나오지 않는다...

if (작업이 충분히 작거나 더이상 분할 할 수 없으면) {
    // 순차적으로 작업 계산 
} else {
    // 두 서브작업으로 분할 
    // 태스크가 다시 서브작업으로 분할되도록 이 메서드를 재귀적으로 호출 
    // 모든 서브작업 완료까지 기다림
    // 서브작업들 결과 합침 
}

public class ForkJoinSumCalculator
    extends java.util.concurrent.RecursiveTask<Long> {
    private final long[] numbers; // 더할 숫자
    private final int start; // 각 서브작업별 시작숫자 
    private final int end;
    public static final long THRESHOLD = 10_000; // 이 값 이하로는 분할 못하게

    public ForkJoinSumCalculator(long[] numbers) { 
        this(numbers, 0, numbers.length);
    }
    
	// 서브잡 재귀적으로 만들 비공개 생성자
    private ForkJoinSumCalculator(long[] numbers, int start, int end) { 
        this.numbers = numbers; 
        this.start = start; 
        this.end = end;
    } 

    @Override 
    protected Long compute() { // RecursiveTask의 추상 메서드 오버라이드
        int length = end - start; 
        if (length <= THRESHOLD) { 
            return computeSequentially();
        } 
        ForkJoinSumCalculator leftTask = 
            new ForkJoinSumCalculator(numbers, start, start + length/2); 
        leftTask.fork();
        ForkJoinSumCalculator rightTask =
            new ForkJoinSumCalculator(numbers, start + length/2, end); 
        Long rightResult = rightTask.compute(); 
        Long leftResult = leftTask.join(); 
        return leftResult + rightResult;
    }

    private long computeSequentially() { 
        long sum = 0;
        for (int i = start; i < end; i++) { 
            sum += numbers[i];
        } 
        return sum; 
    }
}

public static long forkJoinSum(long n) {
    long[] numbers = LongStream.rangeClosed(1, n).toArray(); 
    ForkJoinTask<Long> task = new ForkJoinSumCalculator(numbers); 
    return new ForkJoinPool().invoke(task);
}

// 위랑 동일 ForkJoinSumCalculator 코드 
public class ForkJoinSumCalculator
    extends java.util.concurrent.RecursiveTask<Long> {
    private final long[] numbers;
    private final int start; 
    private final int end;
    public static final long THRESHOLD = 10_000; 

    public ForkJoinSumCalculator(long[] numbers) { 
        this(numbers, 0, numbers.length);
    }

    private ForkJoinSumCalculator(long[] numbers, int start, int end) { 
        this.numbers = numbers; 
        this.start = start; 
        this.end = end;
    } 

    @Override 
    protected Long compute() { 
        int length = end - start; 
        if (length <= THRESHOLD) { 
            return computeSequentially();
        } 
        ForkJoinSumCalculator leftTask = 
            new ForkJoinSumCalculator(numbers, start, start + length/2); 
        leftTask.fork();
        ForkJoinSumCalculator rightTask =
            new ForkJoinSumCalculator(numbers, start + length/2, end); 
        Long rightResult = rightTask.compute(); 
        // 아래 join()은...
        // 결과가 준비될때까지, 호출자를 블록시킨다 .
        // 각각 서브 작업이 다른 테스트가 끝나길 기다리는 일 발생을 막아준다. 
        Long leftResult = leftTask.join(); 
        return leftResult + rightResult;
    }

    private long computeSequentially() { 
        long sum = 0;
        for (int i = start; i < end; i++) { 
            sum += numbers[i];
        } 
        return sum; 
    }
}

public static long forkJoinSum(long n) {
    long[] numbers = LongStream.rangeClosed(1, n).toArray();
    ForkJoinTask<Long> task = new ForkJoinSumCalculator(numbers);
    // RecursiveTask의 invoke()는
    // 병렬 계산을 시작할때만 사용 
    return FORK_JOIN_POOL.invoke(task); 
}

public static void main(String[] args) {
    forkJoinSum(100_000);
}

public interface Spliterator<T> {
    // 요소를 순차적으로 소비하며 탐색할 요소가 있으면 참 반환. (iterator랑 비슷)
    boolean tryAdvance(Consumer<? super T> action);
    // 일부요소를 분할해서 두번째 Spliterator를 생성 리턴
    Spliterator<T> trySplit();
    // 탐색해야될 요소수 정보를 제공 
    long estimateSize();
    // Spliterator의 특성 집합을 포함하는 int 반환 
    int characteristics(); // ORDERED, DISTINCT, SORTED, SIZED, IMMUTABLE, CONCURRENT, SUBSIZED
}

final String SENTENCE =
    "Nel mezzo del cammin di nostra vita " +
    "mi ritrovai in una selva oscura" +
    " ché la dritta via era smarrita ";

System.out.println("Found " + countWordsIteratively(SENTENCE) + " words");

public int countWordsIteratively(String s) {
    int counter = 0;
    boolean lastSpace = true;
    for (char c : s.toCharArray()) {
        if (Character.isWhitespace(c)) {
            lastSpace = true;
        } else {
            if (lastSpace) counter++;
            lastSpace = false;
        }
    }
    return counter;
}

// main 코드 
Stream<Character> stream = IntStream.range(0, SENTENCE.length())
    							  .mapToObj(SENTENCE::charAt);

// 만들어진 스트림: [N, e, l,  , m, e, z, z, o,  , d, e, l,  , c, a, m, m, i, n,  , d, i,  , n, o, s, t, r, a,  , v, i, t, a,  , m, i,  , r, i, t, r, o, v, a, i,  , i, n,  , u, n, a,  , s, e, l, v, a,  , o, s, c, u, r, a,  , c, h, é,  , l, a,  , d, r, i, t, t, a,  , v, i, a,  , e, r, a,  , s, m, a, r, r, i, t, a,  ]

System.out.println("Found " + countWords(stream) + " words");

private int countWords(Stream<Character> stream) {
    WordCounter wordCounter = stream.reduce(new WordCounter(0, true),
                                            WordCounter::accumulate,
                                            WordCounter::combine);
    return wordCounter.getCounter();
}

class WordCounter {
    private final int counter;
    private final boolean lastSpace;
    public WordCounter(int counter, boolean lastSpace) {
        this.counter = counter;
        this.lastSpace = lastSpace;
    }
    // 
    public WordCounter accumulate(Character c) {
        if (Character.isWhitespace(c)) {
            return lastSpace ?
                this : new WordCounter(counter, true);
        } else {
            return lastSpace ?
                new WordCounter(counter + 1, false) : this;
        }
    }
    // 서브작업에서 계산된 counter들을 합치는 역할. 
    public WordCounter combine(WordCounter wordCounter) {
        return new WordCounter(counter + wordCounter.counter,
                               wordCounter.lastSpace);
    }
    public int getCounter() {
        return counter;
    }
}

// main 코드
// stream에 parallel() 추가
System.out.println("Found " + countWords(stream.parallel()) + " words");

public static void main(String[] args) {
    Spliterator<Character> spliterator = new WordCounterSpliterator(SENTENCE);
    Stream<Character> stream = StreamSupport.stream(spliterator, true);
    System.out.println("Found " + countWords(stream) + " words");
}

private static int countWords(Stream<Character> stream) {
    WordCounter wordCounter = stream.reduce(new WordCounter(0, true),
                                            WordCounter::accumulate,
                                            WordCounter::combine);
    return wordCounter.getCounter();
}

class WordCounterSpliterator implements Spliterator<Character> {
    private final String string;
    private int currentChar = 0;
    public WordCounterSpliterator(String string) {
        this.string = string;
    }
    @Override
    public boolean tryAdvance(Consumer<? super Character> action) {
        action.accept(string.charAt(currentChar++));
        return currentChar < string.length();
    }
    @Override
    public Spliterator<Character> trySplit() {
        int currentSize = string.length() - currentChar;
        if (currentSize < 10) { 
            return null;
        }
        for (int splitPos = currentSize / 2 + currentChar; splitPos < string.length(); splitPos++) {
            if (Character.isWhitespace(string.charAt(splitPos))) {
                Spliterator<Character> spliterator =
                    new WordCounterSpliterator(string.substring(currentChar,
                                                                splitPos));
                currentChar = splitPos;
                return spliterator;
            }
        }
        return null;
    }
    @Override
    public long estimateSize() {
        return string.length() - currentChar;
    }
    @Override
    public int characteristics() {
        return ORDERED + SIZED + SUBSIZED + NON-NULL + IMMUTABLE;
    }
}