import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.LongAccumulator;
import java.util.concurrent.atomic.LongAdder;
import java.util.function.LongBinaryOperator;
import java.util.stream.IntStream;
import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;

@Warmup(iterations = 5)
@Measurement(iterations = 10)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@State(Scope.Benchmark)
@Fork(2)
public class Sum {

    public static void stop(ExecutorService executor) {
        try {
            executor.shutdown();
            executor.awaitTermination(60, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            System.err.println("termination interrupted");
        } finally {
            if (!executor.isTerminated()) {
                System.err.println("killing non-finished tasks");
            }
            executor.shutdownNow();
        }
    }

    public static int fori(int n) {

        long sum = 0;
        for (int i = 0; i < n; i++) {
            sum += i;

        }

        return (int) sum;
    }

    public static int longAdder(int n) {
        LongAdder adder = new LongAdder();

        ExecutorService executor = Executors.newFixedThreadPool(4);

        IntStream.range(0, n)
                .forEach(i -> executor.submit(adder::increment));

        stop(executor);

        return adder.intValue();
    }

    public static int atomicInteger(int n) {
        AtomicInteger atomicInt = new AtomicInteger(0);

        ExecutorService executor = Executors.newFixedThreadPool(4);

        IntStream.range(0, n)
                .forEach(i -> executor.submit(atomicInt::incrementAndGet));

        stop(executor);

        return atomicInt.intValue();
    }

    public static int longAccumulator(int n) {

        LongBinaryOperator op = (x, y) -> x + y;

        LongAccumulator accumulator = new LongAccumulator(op, 1L);;

        ExecutorService executor = Executors.newFixedThreadPool(4);

        IntStream.range(0, n)
                .forEach(i -> executor.submit(() -> accumulator.accumulate(i)));

        stop(executor);

        return accumulator.intValue();
    }

    @Param({"1000", "10000", "100000", "1000000", "10000000"})
    private int n;

    @Benchmark
    public void testLongAdder(Blackhole bh) {
        bh.consume(longAdder(n));
    }

    @Benchmark
    public void testAtomicInteger(Blackhole bh) {
        bh.consume(atomicInteger(n));
    }

    @Benchmark
    public void testLongAccumulator(Blackhole bh) {
        bh.consume(longAccumulator(n));
    }
    @Benchmark
    public void testFori(Blackhole bh) {
        bh.consume(fori(n));
    }

    public static void main(String[] args) throws RunnerException {
        Options opt = new OptionsBuilder()
                .include(Sum.class.getSimpleName())
                .forks(1)
                .build();

        new Runner(opt).run();
    }

}