Разбор перформансных задач с JBreak (Часть 1)

в 18:36, , рубрики: foreach, java, jit, JIT-компилятор, stream api, Блог компании Контур, высокая производительность, Компиляторы, микрооптимизация, Программирование, производительность

Первая часть — разбор самой холиварной задачи из четырёх:

    void forEach(List<Integer> values, PrintStream ps) {
        values.forEach(ps::println);
    }

    void forEach(List<Integer> values, PrintStream ps) {
        values.stream().forEach(ps::println);
    }

    void forEach(List<Integer> values, PrintStream ps) {
        values.parallelStream().forEach(ps::println);
    }

Под катом условие задач, история их появления, а также разбор первой задачи и статистика её правильных решений среди участников конференции.

Предисловие

Коллега за десять дней до конференции пришёл с предложением подготовить задачи для розыгрыша призов, где топовыми призами стали бы несколько книг Effective Java от Джошуа Блоха (последнее третье издание). Под такие призы нужны соответствующие задачи. И так, вызов принят.

Для начала определимся, что мы хотим получить:

  • задачи должны быть на код (я не мастер придумывать логические задачи, а брать готовые не хотелось)
  • в задачах должен быть очевидный неправильный ответ
  • задачи не должны быть все простыми или все сложными
  • если закодить задачу, то это не должно дать 100% ответа, но может помочь в поиске верного решения
  • в идеале задачи должны «зацепить», чтобы после конференции было желание докопаться до истины.

Так я решился подготовить задачи про перформанс в следующем виде:

  • несколько вариантов алгоритмов, делающих что-то похожее
  • требуется упорядочить их по скорости работы
  • и объяснить, почему алгоритмы упорядочены именно таким образом.

Задачи

Как выглядело условие задачи в печатном виде

Разбор перформансных задач с JBreak (Часть 1) - 1

Комментарий ко всем задачам:

  • Упорядочить методы по скорости их работы и вписать номера методов в соответствующую ячейку.
  • Если методы дают незначительно отличающиеся результаты, тогда вписать их в одну ячейку.
  • По каждой задаче написать разъяснение, почему одни методы быстрее других.

Задача №1

    void forEach(List<Integer> values, PrintStream ps) {
        values.forEach(ps::println);
    }

    void forEach(List<Integer> values, PrintStream ps) {
        values.stream().forEach(ps::println);
    }

    void forEach(List<Integer> values, PrintStream ps) {
        values.parallelStream().forEach(ps::println);
    }

Задача №2

    String format(String user, String grade, String company, String message) {
        return String.format(
                "Он, %s, придумал такие %s задачи. Приду на стенд %s и скажу ему %s",
                user, grade, company, message);
    }

    String format(String user, String grade, String company, String message) {
        return "Он, " + user
                + ", придумал такие " + grade
                + " задачи. Приду на стенд " + company
                + " и скажу ему " + message;
    }

    String format(String user, String grade, String company, String message) {
        return new StringBuilder("Он, ")
                .append(user)
                .append(", придумал такие ")
                .append(grade)
                .append(" задачи. Приду на стенд ")
                .append(company)
                .append(" и скажу ему ")
                .append(message)
                .toString();
    }

Задача №3

    public static double compute(
            double x1, double y1, double z1,
            double x2, double y2, double z2) {
        double x = y1 * z2 - z1 * y2;
        double y = z1 * x2 - x1 * z2;
        double z = x1 * y2 - y1 * x2;
        return x * x + y * y + z * z;
    }

    public static double compute(
            double x1, double y1, double z1,
            double x2, double y2, double z2) {
        Vector v1 = new Vector(x1, y1, z1);
        Vector v2 = new Vector(x2, y2, z2);
        return v1.crossProduct(v2).squared();
    }

    public final static class Vector {
        private final double x, y, z;

        public Vector(double x, double y, double z) {
            this.x = x; this.y = y; this.z = z;
        }

        public double squared() {
            return x * x + y * y + z * z;
        }

        public Vector crossProduct(Vector v) {
            return new Vector(
                    y * v.z - z * v.y,
                    z * v.x - x * v.z,
                    x * v.y - y * v.x);
        }
    }

Задача №4

    public double octaPow(double a) {
        return Math.pow(a, 8);
    }

    public double octaPow(double a) {
        return a * a * a * a * a * a * a * a;
    }

    public double octaPow(double a) {
        return Math.pow(Math.pow(Math.pow(a, 2), 2), 2);
    }

    public double octaPow(double a) {
        a *= a; a *= a; return a * a;
    }

Предполагается, что код запускается в HotSpot 64-bit VM (JRE 1.8.0_161). В выбранной версии JRE нет ничего специфического, кроме того, что она одна из последних и уже у меня стояла — разумеется, что все задачи я должен был заранее проверить.

Неявно предполагается, что код запускается на многоядерном железе с архитектурой intel 64 (x86-64). Возможно, стоило это указать явно, но и дополнительные условия могли ввести в заблуждение. При этом, если пояснение к ответу в задаче учитывало специфику другого железа, то решение бы засчитывалось.

Задача №1

«foreach — это быстро», «Стримы тормозят», «Параллельно значит быстро» частенько доносилось из обсуждений Stream API, которому вот уже стукнет 4 года (если считать с даты публичного релиза Java 8). Так и я поддался пошёл на провокацию:

    void forEach(List<Integer> values, PrintStream ps) {
        values.forEach(ps::println);
    }

    void forEach(List<Integer> values, PrintStream ps) {
        values.stream().forEach(ps::println);
    }

    void forEach(List<Integer> values, PrintStream ps) {
        values.parallelStream().forEach(ps::println);
    }

Очевидный неправильный ответ: 3 вариант самый быстрый.

У многих сработал триггер «Параллельно значит быстро» и они попали в ловушку с PrintStream.

Фрагмент исходного кода PrintStream:

    public void println(Object x) {
        String s = String.valueOf(x);
        synchronized (this) {
            print(s);
            newLine();
        }
    }

На практике это означает, что никакой выгоды от параллельного выполнения мы не получим независимо от размеров списка values. Напротив, мы получим деградацию производительности, так как виртуальной машине придётся постоянно разруливать множественные блокировки на PrintStream.

List.stream().forEach() vs List.parallelStream().forEach()

Ниже бенчмарк для сравнения обычного последовательного и параллельного Stream.

Бенчмарк

package ru.gnkoshelev.jbreak2018.perf_tests.for_each;

@Fork(value = 1, warmups = 0)
@Warmup(iterations = 5, time = 2_000, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 10, time = 2_000, timeUnit = TimeUnit.MILLISECONDS)
@OutputTimeUnit(value = TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
public class StreamDefaultBenchmark {
    static int N = 1000;

    static List<Integer> values;

    static {
        Random rand = new Random(12345);

        int size = N;
        values = new ArrayList<>();

        for (int i = 0; i < size; i++) {
            values.add(rand.nextInt());
        }
    }

    @State(value = Scope.Benchmark)
    public static class PrintStreamHolder {
        PrintStream ps;

        @Setup(value = Level.Iteration)
        public void setup() {
            ps = new PrintStream(new NullOutputStream());
        }
    }

    @Benchmark
    public void forEachStreamBenchmark(PrintStreamHolder psh) {
        forEachStream(values, psh.ps);
    }

    @Benchmark
    public void forEachParallelStreamBenchmark(PrintStreamHolder psh) {
        forEachParallelStream(values, psh.ps);
    }

    public void forEachStream(List<Integer> values, PrintStream ps) {
        values.stream().forEach(ps::println);
    }

    public void forEachParallelStream(List<Integer> values, PrintStream ps) {
        values.parallelStream().forEach(ps::println);
    }
}

Результаты

# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: <none>
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.StreamDefaultBenchmark.forEachParallelStreamBenchmark

# Run progress: 0,00% complete, ETA 00:01:00
# Fork: 1 of 1
# Warmup Iteration   1: 905,302 us/op
# Warmup Iteration   2: 876,525 us/op
# Warmup Iteration   3: 921,153 us/op
# Warmup Iteration   4: 898,899 us/op
# Warmup Iteration   5: 873,496 us/op
Iteration   1: 920,439 us/op
Iteration   2: 894,216 us/op
Iteration   3: 917,930 us/op
Iteration   4: 906,970 us/op
Iteration   5: 929,685 us/op
Iteration   6: 883,136 us/op
Iteration   7: 883,996 us/op
Iteration   8: 882,597 us/op
Iteration   9: 921,612 us/op
Iteration  10: 885,576 us/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.StreamDefaultBenchmark.forEachParallelStreamBenchmark":
  902,616 ±(99.9%) 28,296 us/op [Average]
  (min, avg, max) = (882,597, 902,616, 929,685), stdev = 18,716
  CI (99.9%): [874,320, 930,911] (assumes normal distribution)


# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: <none>
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.StreamDefaultBenchmark.forEachStreamBenchmark

# Run progress: 50,00% complete, ETA 00:00:30
# Fork: 1 of 1
# Warmup Iteration   1: 285,837 us/op
# Warmup Iteration   2: 265,208 us/op
# Warmup Iteration   3: 157,321 us/op
# Warmup Iteration   4: 157,447 us/op
# Warmup Iteration   5: 157,689 us/op
Iteration   1: 157,192 us/op
Iteration   2: 161,511 us/op
Iteration   3: 161,464 us/op
Iteration   4: 156,948 us/op
Iteration   5: 158,526 us/op
Iteration   6: 163,035 us/op
Iteration   7: 159,140 us/op
Iteration   8: 158,476 us/op
Iteration   9: 158,884 us/op
Iteration  10: 159,072 us/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.StreamDefaultBenchmark.forEachStreamBenchmark":
  159,425 ±(99.9%) 2,976 us/op [Average]
  (min, avg, max) = (156,948, 159,425, 163,035), stdev = 1,969
  CI (99.9%): [156,448, 162,401] (assumes normal distribution)


# Run complete. Total time: 00:01:00

Benchmark                                              Mode  Cnt    Score    Error  Units
StreamDefaultBenchmark.forEachParallelStreamBenchmark  avgt   10  902,616 ± 28,296  us/op
StreamDefaultBenchmark.forEachStreamBenchmark          avgt   10  159,425 ±  2,976  us/op

Понятно, что при однопоточном исполнении блокировка никуда не девается. Но виртуальная машина может поступать достаточно хитро, а именно не делать настоящую (на уровне OS) блокировку, а ограничиваться так называемой biased locking, если отсутствует contention на ресурсе.

Можем отключить biased locking и посмотреть, что получится:

Бенчмарк без biased locking

package ru.gnkoshelev.jbreak2018.perf_tests.for_each;

@Fork(value = 1, warmups = 0, jvmArgsAppend = "-XX:-UseBiasedLocking")
@Warmup(iterations = 5, time = 2_000, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 10, time = 2_000, timeUnit = TimeUnit.MILLISECONDS)
@OutputTimeUnit(value = TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
public class StreamWithoutBiasedLockingBenchmark {
    static int N = 1000;

    static List<Integer> values;

    static {
        Random rand = new Random(12345);

        int size = N;
        values = new ArrayList<>();

        for (int i = 0; i < size; i++) {
            values.add(rand.nextInt());
        }
    }

    @State(value = Scope.Benchmark)
    public static class PrintStreamHolder {
        PrintStream ps;

        @Setup(value = Level.Iteration)
        public void setup() {
            ps = new PrintStream(new NullOutputStream());
        }
    }

    @Benchmark
    public void forEachStreamBenchmark(PrintStreamHolder psh) {
        forEachStream(values, psh.ps);
    }

    @Benchmark
    public void forEachParallelStreamBenchmark(PrintStreamHolder psh) {
        forEachParallelStream(values, psh.ps);
    }

    public void forEachStream(List<Integer> values, PrintStream ps) {
        values.stream().forEach(ps::println);
    }

    public void forEachParallelStream(List<Integer> values, PrintStream ps) {
        values.parallelStream().forEach(ps::println);
    }
}

Результаты

# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: -XX:-UseBiasedLocking
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.StreamWithoutBiasedLockingBenchmark.forEachParallelStreamBenchmark

# Run progress: 0,00% complete, ETA 00:01:00
# Fork: 1 of 1
# Warmup Iteration   1: 754,310 us/op
# Warmup Iteration   2: 723,277 us/op
# Warmup Iteration   3: 682,845 us/op
# Warmup Iteration   4: 696,635 us/op
# Warmup Iteration   5: 690,811 us/op
Iteration   1: 702,129 us/op
Iteration   2: 729,542 us/op
Iteration   3: 689,514 us/op
Iteration   4: 716,482 us/op
Iteration   5: 734,766 us/op
Iteration   6: 684,455 us/op
Iteration   7: 682,483 us/op
Iteration   8: 706,857 us/op
Iteration   9: 690,011 us/op
Iteration  10: 694,427 us/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.StreamWithoutBiasedLockingBenchmark.forEachParallelStreamBenchmark":
  703,067 ±(99.9%) 28,058 us/op [Average]
  (min, avg, max) = (682,483, 703,067, 734,766), stdev = 18,559
  CI (99.9%): [675,008, 731,125] (assumes normal distribution)


# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: -XX:-UseBiasedLocking
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.StreamWithoutBiasedLockingBenchmark.forEachStreamBenchmark

# Run progress: 50,00% complete, ETA 00:00:30
# Fork: 1 of 1
# Warmup Iteration   1: 271,938 us/op
# Warmup Iteration   2: 258,261 us/op
# Warmup Iteration   3: 257,976 us/op
# Warmup Iteration   4: 256,103 us/op
# Warmup Iteration   5: 255,863 us/op
Iteration   1: 266,376 us/op
Iteration   2: 258,158 us/op
Iteration   3: 278,038 us/op
Iteration   4: 271,354 us/op
Iteration   5: 256,021 us/op
Iteration   6: 254,590 us/op
Iteration   7: 254,944 us/op
Iteration   8: 255,525 us/op
Iteration   9: 256,339 us/op
Iteration  10: 257,311 us/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.StreamWithoutBiasedLockingBenchmark.forEachStreamBenchmark":
  260,866 ±(99.9%) 12,366 us/op [Average]
  (min, avg, max) = (254,590, 260,866, 278,038), stdev = 8,180
  CI (99.9%): [248,499, 273,232] (assumes normal distribution)


# Run complete. Total time: 00:01:00

Benchmark                                                           Mode  Cnt    Score    Error  Units
StreamWithoutBiasedLockingBenchmark.forEachParallelStreamBenchmark  avgt   10  703,067 ± 28,058  us/op
StreamWithoutBiasedLockingBenchmark.forEachStreamBenchmark          avgt   10  260,866 ± 12,366  us/op

Ожидаемо просела производительность обычного ArrayList.forEach(). При этом по прогревочным итерациям в предыдущем бенчмарке заметно ускорение, начиная с третьей итерации, — это не случайность. Дело в том, что по умолчанию biased locking включается спустя 4000 мс с момента запуска виртуальной машины. Это значение можно потюнить и посмотреть, что получится:

Бенчмарк c увеличенным временем включения biased locking

package ru.gnkoshelev.jbreak2018.perf_tests.for_each;

@Fork(value = 1, warmups = 0, jvmArgsAppend = "-XX:BiasedLockingStartupDelay=6000")
@Warmup(iterations = 5, time = 2_000, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 10, time = 2_000, timeUnit = TimeUnit.MILLISECONDS)
@OutputTimeUnit(value = TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
public class StreamWithNewBiasedLockingStartupDelayBenchmark {
    static int N = 1000;

    static List<Integer> values;

    static {
        Random rand = new Random(12345);

        int size = N;
        values = new ArrayList<>();

        for (int i = 0; i < size; i++) {
            values.add(rand.nextInt());
        }
    }

    @State(value = Scope.Benchmark)
    public static class PrintStreamHolder {
        PrintStream ps;

        @Setup(value = Level.Iteration)
        public void setup() {
            ps = new PrintStream(new NullOutputStream());
        }
    }

    @Benchmark
    public void forEachStreamBenchmark(PrintStreamHolder psh) {
        forEachStream(values, psh.ps);
    }

    @Benchmark
    public void forEachParallelStreamBenchmark(PrintStreamHolder psh) {
        forEachParallelStream(values, psh.ps);
    }

    public void forEachStream(List<Integer> values, PrintStream ps) {
        values.stream().forEach(ps::println);
    }

    public void forEachParallelStream(List<Integer> values, PrintStream ps) {
        values.parallelStream().forEach(ps::println);
    }
}

Результаты

# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: -XX:BiasedLockingStartupDelay=6000
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.StreamWithNewBiasedLockingStartupDelayBenchmark.forEachParallelStreamBenchmark

# Run progress: 0,00% complete, ETA 00:01:00
# Fork: 1 of 1
# Warmup Iteration   1: 954,533 us/op
# Warmup Iteration   2: 866,854 us/op
# Warmup Iteration   3: 907,109 us/op
# Warmup Iteration   4: 914,717 us/op
# Warmup Iteration   5: 924,102 us/op
Iteration   1: 912,619 us/op
Iteration   2: 947,812 us/op
Iteration   3: 925,730 us/op
Iteration   4: 933,807 us/op
Iteration   5: 935,927 us/op
Iteration   6: 852,369 us/op
Iteration   7: 882,498 us/op
Iteration   8: 852,625 us/op
Iteration   9: 898,787 us/op
Iteration  10: 1150,831 us/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.StreamWithNewBiasedLockingStartupDelayBenchmark.forEachParallelStreamBenchmark":
  929,301 ±(99.9%) 128,179 us/op [Average]
  (min, avg, max) = (852,369, 929,301, 1150,831), stdev = 84,783
  CI (99.9%): [801,121, 1057,480] (assumes normal distribution)


# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: -XX:BiasedLockingStartupDelay=6000
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.StreamWithNewBiasedLockingStartupDelayBenchmark.forEachStreamBenchmark

# Run progress: 50,00% complete, ETA 00:00:30
# Fork: 1 of 1
# Warmup Iteration   1: 346,853 us/op
# Warmup Iteration   2: 280,643 us/op
# Warmup Iteration   3: 264,425 us/op
# Warmup Iteration   4: 169,200 us/op
# Warmup Iteration   5: 167,981 us/op
Iteration   1: 171,230 us/op
Iteration   2: 169,891 us/op
Iteration   3: 169,124 us/op
Iteration   4: 167,938 us/op
Iteration   5: 167,471 us/op
Iteration   6: 176,187 us/op
Iteration   7: 171,791 us/op
Iteration   8: 170,127 us/op
Iteration   9: 169,563 us/op
Iteration  10: 169,062 us/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.StreamWithNewBiasedLockingStartupDelayBenchmark.forEachStreamBenchmark":
  170,238 ±(99.9%) 3,736 us/op [Average]
  (min, avg, max) = (167,471, 170,238, 176,187), stdev = 2,471
  CI (99.9%): [166,503, 173,974] (assumes normal distribution)


# Run complete. Total time: 00:01:00

Benchmark                                                                       Mode  Cnt    Score     Error  Units
StreamWithNewBiasedLockingStartupDelayBenchmark.forEachParallelStreamBenchmark  avgt   10  929,301 ± 128,179  us/op
StreamWithNewBiasedLockingStartupDelayBenchmark.forEachStreamBenchmark          avgt   10  170,238 ±   3,736  us/op

Как и ожидалось, эффект от biased locking наступил только спустя 6 секунд с начала выполнения бенчмарка — это видно по разнице во времени выполнения третьей и четвёртой прогревочной итерации.

List.forEach() vs List.stream().forEach()

Теперь пришло время разобраться, что быстрее: List.forEach() или List.stream().forEach(). Правильный ответ «зависит от». На результат влияет размер списка, тип списка, возможность применения инлайнинга и других оптимизаций JIT-компилятором. Возможно, нам удастся выявить общее правило. Ниже результат для ArrayList:

Бенчмарк

package ru.gnkoshelev.jbreak2018.perf_tests.for_each;

@Fork(value = 1, warmups = 0)
@Warmup(iterations = 5, time = 2_000, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 10, time = 2_000, timeUnit = TimeUnit.MILLISECONDS)
@OutputTimeUnit(value = TimeUnit.MICROSECONDS)
@BenchmarkMode(Mode.AverageTime)
@State(Scope.Benchmark)
public class ArrayListVsStreamBenchmark {
    @Param(value = {"1", "10", "100", "1000", "10000"})
    public int N;

    private List<Integer> values;

    @Setup
    public void setup() {
        Random rand = new Random(12345);

        int size = N;
        values = new ArrayList<>();

        for (int i = 0; i < size; i++) {
            values.add(rand.nextInt());
        }
    }

    @State(value = Scope.Benchmark)
    public static class PrintStreamHolder {
        PrintStream ps;

        @Setup(value = Level.Iteration)
        public void setup() {
            ps = new PrintStream(new NullOutputStream());
        }
    }

    @Benchmark
    public void forEachListBenchmark(PrintStreamHolder psh) {
        forEachList(values, psh.ps);
    }

    @Benchmark
    public void forEachStreamBenchmark(PrintStreamHolder psh) {
        forEachStream(values, psh.ps);
    }

    public void forEachList(List<Integer> values, PrintStream ps) {
        values.forEach(ps::println);
    }

    public void forEachStream(List<Integer> values, PrintStream ps) {
        values.stream().forEach(ps::println);
    }
}

Результаты

# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: <none>
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.ArrayListVsStreamBenchmark.forEachListBenchmark
# Parameters: (N = 1)

# Run progress: 0,00% complete, ETA 00:05:00
# Fork: 1 of 1
# Warmup Iteration   1: 0,288 us/op
# Warmup Iteration   2: 0,277 us/op
# Warmup Iteration   3: 0,178 us/op
# Warmup Iteration   4: 0,177 us/op
# Warmup Iteration   5: 0,178 us/op
Iteration   1: 0,177 us/op
Iteration   2: 0,178 us/op
Iteration   3: 0,178 us/op
Iteration   4: 0,178 us/op
Iteration   5: 0,178 us/op
Iteration   6: 0,178 us/op
Iteration   7: 0,178 us/op
Iteration   8: 0,179 us/op
Iteration   9: 0,178 us/op
Iteration  10: 0,180 us/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.ArrayListVsStreamBenchmark.forEachListBenchmark":
  0,178 ±(99.9%) 0,001 us/op [Average]
  (min, avg, max) = (0,177, 0,178, 0,180), stdev = 0,001
  CI (99.9%): [0,177, 0,179] (assumes normal distribution)


# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: <none>
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.ArrayListVsStreamBenchmark.forEachListBenchmark
# Parameters: (N = 10)

# Run progress: 10,00% complete, ETA 00:04:33
# Fork: 1 of 1
# Warmup Iteration   1: 2,933 us/op
# Warmup Iteration   2: 2,839 us/op
# Warmup Iteration   3: 1,661 us/op
# Warmup Iteration   4: 1,675 us/op
# Warmup Iteration   5: 1,674 us/op
Iteration   1: 1,682 us/op
Iteration   2: 1,653 us/op
Iteration   3: 1,658 us/op
Iteration   4: 1,656 us/op
Iteration   5: 1,659 us/op
Iteration   6: 1,655 us/op
Iteration   7: 1,656 us/op
Iteration   8: 1,657 us/op
Iteration   9: 1,661 us/op
Iteration  10: 1,660 us/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.ArrayListVsStreamBenchmark.forEachListBenchmark":
  1,660 ±(99.9%) 0,013 us/op [Average]
  (min, avg, max) = (1,653, 1,660, 1,682), stdev = 0,008
  CI (99.9%): [1,647, 1,672] (assumes normal distribution)


# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: <none>
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.ArrayListVsStreamBenchmark.forEachListBenchmark
# Parameters: (N = 100)

# Run progress: 20,00% complete, ETA 00:04:02
# Fork: 1 of 1
# Warmup Iteration   1: 27,633 us/op
# Warmup Iteration   2: 27,184 us/op
# Warmup Iteration   3: 15,046 us/op
# Warmup Iteration   4: 15,064 us/op
# Warmup Iteration   5: 15,060 us/op
Iteration   1: 15,039 us/op
Iteration   2: 15,057 us/op
Iteration   3: 15,065 us/op
Iteration   4: 15,062 us/op
Iteration   5: 15,086 us/op
Iteration   6: 15,060 us/op
Iteration   7: 15,110 us/op
Iteration   8: 15,070 us/op
Iteration   9: 15,111 us/op
Iteration  10: 15,079 us/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.ArrayListVsStreamBenchmark.forEachListBenchmark":
  15,074 ±(99.9%) 0,035 us/op [Average]
  (min, avg, max) = (15,039, 15,074, 15,111), stdev = 0,023
  CI (99.9%): [15,039, 15,109] (assumes normal distribution)


# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: <none>
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.ArrayListVsStreamBenchmark.forEachListBenchmark
# Parameters: (N = 1000)

# Run progress: 30,00% complete, ETA 00:03:32
# Fork: 1 of 1
# Warmup Iteration   1: 291,532 us/op
# Warmup Iteration   2: 267,136 us/op
# Warmup Iteration   3: 170,432 us/op
# Warmup Iteration   4: 170,388 us/op
# Warmup Iteration   5: 169,797 us/op
Iteration   1: 170,036 us/op
Iteration   2: 176,614 us/op
Iteration   3: 176,396 us/op
Iteration   4: 175,895 us/op
Iteration   5: 176,984 us/op
Iteration   6: 172,085 us/op
Iteration   7: 170,193 us/op
Iteration   8: 171,333 us/op
Iteration   9: 170,293 us/op
Iteration  10: 171,006 us/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.ArrayListVsStreamBenchmark.forEachListBenchmark":
  173,084 ±(99.9%) 4,518 us/op [Average]
  (min, avg, max) = (170,036, 173,084, 176,984), stdev = 2,988
  CI (99.9%): [168,566, 177,601] (assumes normal distribution)


# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: <none>
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.ArrayListVsStreamBenchmark.forEachListBenchmark
# Parameters: (N = 10000)

# Run progress: 40,00% complete, ETA 00:03:01
# Fork: 1 of 1
# Warmup Iteration   1: 2890,241 us/op
# Warmup Iteration   2: 2784,740 us/op
# Warmup Iteration   3: 1725,390 us/op
# Warmup Iteration   4: 1726,138 us/op
# Warmup Iteration   5: 1733,212 us/op
Iteration   1: 1726,084 us/op
Iteration   2: 1712,973 us/op
Iteration   3: 1715,916 us/op
Iteration   4: 1750,530 us/op
Iteration   5: 1721,900 us/op
Iteration   6: 1711,158 us/op
Iteration   7: 1709,659 us/op
Iteration   8: 1726,751 us/op
Iteration   9: 1737,237 us/op
Iteration  10: 1734,220 us/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.ArrayListVsStreamBenchmark.forEachListBenchmark":
  1724,643 ±(99.9%) 19,861 us/op [Average]
  (min, avg, max) = (1709,659, 1724,643, 1750,530), stdev = 13,137
  CI (99.9%): [1704,782, 1744,504] (assumes normal distribution)


# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: <none>
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.ArrayListVsStreamBenchmark.forEachStreamBenchmark
# Parameters: (N = 1)

# Run progress: 50,00% complete, ETA 00:02:31
# Fork: 1 of 1
# Warmup Iteration   1: 0,301 us/op
# Warmup Iteration   2: 0,289 us/op
# Warmup Iteration   3: 0,181 us/op
# Warmup Iteration   4: 0,180 us/op
# Warmup Iteration   5: 0,181 us/op
Iteration   1: 0,179 us/op
Iteration   2: 0,178 us/op
Iteration   3: 0,179 us/op
Iteration   4: 0,180 us/op
Iteration   5: 0,179 us/op
Iteration   6: 0,179 us/op
Iteration   7: 0,180 us/op
Iteration   8: 0,179 us/op
Iteration   9: 0,180 us/op
Iteration  10: 0,180 us/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.ArrayListVsStreamBenchmark.forEachStreamBenchmark":
  0,179 ±(99.9%) 0,001 us/op [Average]
  (min, avg, max) = (0,178, 0,179, 0,180), stdev = 0,001
  CI (99.9%): [0,178, 0,180] (assumes normal distribution)


# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: <none>
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.ArrayListVsStreamBenchmark.forEachStreamBenchmark
# Parameters: (N = 10)

# Run progress: 60,00% complete, ETA 00:02:01
# Fork: 1 of 1
# Warmup Iteration   1: 2,660 us/op
# Warmup Iteration   2: 2,551 us/op
# Warmup Iteration   3: 1,558 us/op
# Warmup Iteration   4: 1,563 us/op
# Warmup Iteration   5: 1,563 us/op
Iteration   1: 1,557 us/op
Iteration   2: 1,553 us/op
Iteration   3: 1,567 us/op
Iteration   4: 1,555 us/op
Iteration   5: 1,569 us/op
Iteration   6: 1,570 us/op
Iteration   7: 1,562 us/op
Iteration   8: 1,561 us/op
Iteration   9: 1,564 us/op
Iteration  10: 1,580 us/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.ArrayListVsStreamBenchmark.forEachStreamBenchmark":
  1,564 ±(99.9%) 0,012 us/op [Average]
  (min, avg, max) = (1,553, 1,564, 1,580), stdev = 0,008
  CI (99.9%): [1,552, 1,576] (assumes normal distribution)


# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: <none>
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.ArrayListVsStreamBenchmark.forEachStreamBenchmark
# Parameters: (N = 100)

# Run progress: 70,00% complete, ETA 00:01:30
# Fork: 1 of 1
# Warmup Iteration   1: 27,754 us/op
# Warmup Iteration   2: 26,859 us/op
# Warmup Iteration   3: 16,456 us/op
# Warmup Iteration   4: 16,548 us/op
# Warmup Iteration   5: 16,432 us/op
Iteration   1: 16,399 us/op
Iteration   2: 16,480 us/op
Iteration   3: 16,517 us/op
Iteration   4: 16,458 us/op
Iteration   5: 16,395 us/op
Iteration   6: 16,471 us/op
Iteration   7: 16,595 us/op
Iteration   8: 16,585 us/op
Iteration   9: 16,460 us/op
Iteration  10: 16,435 us/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.ArrayListVsStreamBenchmark.forEachStreamBenchmark":
  16,479 ±(99.9%) 0,104 us/op [Average]
  (min, avg, max) = (16,395, 16,479, 16,595), stdev = 0,069
  CI (99.9%): [16,376, 16,583] (assumes normal distribution)


# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: <none>
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.ArrayListVsStreamBenchmark.forEachStreamBenchmark
# Parameters: (N = 1000)

# Run progress: 80,00% complete, ETA 00:01:00
# Fork: 1 of 1
# Warmup Iteration   1: 291,695 us/op
# Warmup Iteration   2: 282,896 us/op
# Warmup Iteration   3: 185,443 us/op
# Warmup Iteration   4: 187,851 us/op
# Warmup Iteration   5: 184,393 us/op
Iteration   1: 184,584 us/op
Iteration   2: 185,349 us/op
Iteration   3: 184,803 us/op
Iteration   4: 184,394 us/op
Iteration   5: 185,371 us/op
Iteration   6: 186,735 us/op
Iteration   7: 185,945 us/op
Iteration   8: 188,592 us/op
Iteration   9: 186,581 us/op
Iteration  10: 187,908 us/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.ArrayListVsStreamBenchmark.forEachStreamBenchmark":
  186,026 ±(99.9%) 2,142 us/op [Average]
  (min, avg, max) = (184,394, 186,026, 188,592), stdev = 1,417
  CI (99.9%): [183,884, 188,168] (assumes normal distribution)


# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: <none>
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.ArrayListVsStreamBenchmark.forEachStreamBenchmark
# Parameters: (N = 10000)

# Run progress: 90,00% complete, ETA 00:00:30
# Fork: 1 of 1
# Warmup Iteration   1: 2896,624 us/op
# Warmup Iteration   2: 2816,471 us/op
# Warmup Iteration   3: 1732,597 us/op
# Warmup Iteration   4: 1798,371 us/op
# Warmup Iteration   5: 1758,489 us/op
Iteration   1: 1615,213 us/op
Iteration   2: 1518,388 us/op
Iteration   3: 1513,955 us/op
Iteration   4: 1520,570 us/op
Iteration   5: 1525,072 us/op
Iteration   6: 1527,055 us/op
Iteration   7: 1547,707 us/op
Iteration   8: 1532,163 us/op
Iteration   9: 1519,474 us/op
Iteration  10: 1529,969 us/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.ArrayListVsStreamBenchmark.forEachStreamBenchmark":
  1534,957 ±(99.9%) 44,959 us/op [Average]
  (min, avg, max) = (1513,955, 1534,957, 1615,213), stdev = 29,737
  CI (99.9%): [1489,998, 1579,915] (assumes normal distribution)


# Run complete. Total time: 00:05:03

Benchmark                                            (N)  Mode  Cnt     Score    Error  Units
ArrayListVsStreamBenchmark.forEachListBenchmark        1  avgt   10     0,178 ±  0,001  us/op
ArrayListVsStreamBenchmark.forEachListBenchmark       10  avgt   10     1,660 ±  0,013  us/op
ArrayListVsStreamBenchmark.forEachListBenchmark      100  avgt   10    15,074 ±  0,035  us/op
ArrayListVsStreamBenchmark.forEachListBenchmark     1000  avgt   10   173,084 ±  4,518  us/op
ArrayListVsStreamBenchmark.forEachListBenchmark    10000  avgt   10  1724,643 ± 19,861  us/op
ArrayListVsStreamBenchmark.forEachStreamBenchmark      1  avgt   10     0,179 ±  0,001  us/op
ArrayListVsStreamBenchmark.forEachStreamBenchmark     10  avgt   10     1,564 ±  0,012  us/op
ArrayListVsStreamBenchmark.forEachStreamBenchmark    100  avgt   10    16,479 ±  0,104  us/op
ArrayListVsStreamBenchmark.forEachStreamBenchmark   1000  avgt   10   186,026 ±  2,142  us/op
ArrayListVsStreamBenchmark.forEachStreamBenchmark  10000  avgt   10  1534,957 ± 44,959  us/op

В действительности, накладные расходы на итерирование намного меньше, чем накладные расходы на вызов метода PrintStream.println(). Чтобы убедиться в этом, достаточно заменить вызов метода PrintStrim.println() на вызов Blackhole.consume() (последний гарантирует, что JIT-компилятор не выпилит ставшую бесполезной часть кода и итерирование отработает). Обратите внимание, что результат уже не в микросекундах, а в наносекундах!

Бенчмарк с Blackhole.consume()

package ru.gnkoshelev.jbreak2018.perf_tests.for_each;

@Fork(value = 1, warmups = 0)
@Warmup(iterations = 5, time = 2_000, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 10, time = 2_000, timeUnit = TimeUnit.MILLISECONDS)
@OutputTimeUnit(value = TimeUnit.NANOSECONDS)
@BenchmarkMode(Mode.AverageTime)
@State(Scope.Benchmark)
public class BlackholeConsumingBenchmark {
    @Param(value = {"1", "10", "100", "1000", "10000"})
    public int N;

    private List<Integer> values;

    @Setup
    public void setup() {
        Random rand = new Random(12345);

        int size = N;
        values = new ArrayList<>();

        for (int i = 0; i < size; i++) {
            values.add(rand.nextInt());
        }
    }

    @Benchmark
    public void forEachListBenchmark(Blackhole bh) {
        forEachList(values, bh);
    }

    @Benchmark
    public void forEachStreamBenchmark(Blackhole bh) {
        forEachStream(values, bh);
    }

    public void forEachList(List<Integer> values, Blackhole bh) {
        values.forEach(bh::consume);
    }

    public void forEachStream(List<Integer> values, Blackhole bh) {
        values.stream().forEach(bh::consume);
    }
}

Результаты

# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: <none>
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.BlackholeConsumingBenchmark.forEachListBenchmark
# Parameters: (N = 1)

# Run progress: 0,00% complete, ETA 00:05:00
# Fork: 1 of 1
# Warmup Iteration   1: 6,866 ns/op
# Warmup Iteration   2: 6,865 ns/op
# Warmup Iteration   3: 6,528 ns/op
# Warmup Iteration   4: 6,524 ns/op
# Warmup Iteration   5: 6,521 ns/op
Iteration   1: 6,519 ns/op
Iteration   2: 6,542 ns/op
Iteration   3: 6,608 ns/op
Iteration   4: 6,590 ns/op
Iteration   5: 6,678 ns/op
Iteration   6: 6,658 ns/op
Iteration   7: 6,756 ns/op
Iteration   8: 6,933 ns/op
Iteration   9: 6,939 ns/op
Iteration  10: 6,811 ns/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.BlackholeConsumingBenchmark.forEachListBenchmark":
  6,703 ±(99.9%) 0,230 ns/op [Average]
  (min, avg, max) = (6,519, 6,703, 6,939), stdev = 0,152
  CI (99.9%): [6,474, 6,933] (assumes normal distribution)


# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: <none>
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.BlackholeConsumingBenchmark.forEachListBenchmark
# Parameters: (N = 10)

# Run progress: 10,00% complete, ETA 00:04:32
# Fork: 1 of 1
# Warmup Iteration   1: 51,655 ns/op
# Warmup Iteration   2: 50,507 ns/op
# Warmup Iteration   3: 50,309 ns/op
# Warmup Iteration   4: 50,886 ns/op
# Warmup Iteration   5: 50,068 ns/op
Iteration   1: 51,218 ns/op
Iteration   2: 50,108 ns/op
Iteration   3: 52,343 ns/op
Iteration   4: 50,745 ns/op
Iteration   5: 51,461 ns/op
Iteration   6: 50,366 ns/op
Iteration   7: 49,976 ns/op
Iteration   8: 50,623 ns/op
Iteration   9: 50,223 ns/op
Iteration  10: 50,125 ns/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.BlackholeConsumingBenchmark.forEachListBenchmark":
  50,719 ±(99.9%) 1,138 ns/op [Average]
  (min, avg, max) = (49,976, 50,719, 52,343), stdev = 0,753
  CI (99.9%): [49,581, 51,857] (assumes normal distribution)


# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: <none>
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.BlackholeConsumingBenchmark.forEachListBenchmark
# Parameters: (N = 100)

# Run progress: 20,00% complete, ETA 00:04:02
# Fork: 1 of 1
# Warmup Iteration   1: 574,874 ns/op
# Warmup Iteration   2: 557,543 ns/op
# Warmup Iteration   3: 557,260 ns/op
# Warmup Iteration   4: 556,273 ns/op
# Warmup Iteration   5: 556,025 ns/op
Iteration   1: 555,532 ns/op
Iteration   2: 558,421 ns/op
Iteration   3: 564,582 ns/op
Iteration   4: 573,368 ns/op
Iteration   5: 576,355 ns/op
Iteration   6: 562,087 ns/op
Iteration   7: 565,229 ns/op
Iteration   8: 574,557 ns/op
Iteration   9: 561,430 ns/op
Iteration  10: 574,486 ns/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.BlackholeConsumingBenchmark.forEachListBenchmark":
  566,605 ±(99.9%) 11,369 ns/op [Average]
  (min, avg, max) = (555,532, 566,605, 576,355), stdev = 7,520
  CI (99.9%): [555,236, 577,974] (assumes normal distribution)


# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: <none>
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.BlackholeConsumingBenchmark.forEachListBenchmark
# Parameters: (N = 1000)

# Run progress: 30,00% complete, ETA 00:03:32
# Fork: 1 of 1
# Warmup Iteration   1: 4782,869 ns/op
# Warmup Iteration   2: 4920,389 ns/op
# Warmup Iteration   3: 4845,857 ns/op
# Warmup Iteration   4: 4847,470 ns/op
# Warmup Iteration   5: 4857,726 ns/op
Iteration   1: 4850,519 ns/op
Iteration   2: 4852,075 ns/op
Iteration   3: 4907,015 ns/op
Iteration   4: 4859,020 ns/op
Iteration   5: 4879,201 ns/op
Iteration   6: 4832,822 ns/op
Iteration   7: 4831,532 ns/op
Iteration   8: 4829,599 ns/op
Iteration   9: 4878,201 ns/op
Iteration  10: 4826,464 ns/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.BlackholeConsumingBenchmark.forEachListBenchmark":
  4854,645 ±(99.9%) 40,238 ns/op [Average]
  (min, avg, max) = (4826,464, 4854,645, 4907,015), stdev = 26,615
  CI (99.9%): [4814,407, 4894,883] (assumes normal distribution)


# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: <none>
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.BlackholeConsumingBenchmark.forEachListBenchmark
# Parameters: (N = 10000)

# Run progress: 40,00% complete, ETA 00:03:01
# Fork: 1 of 1
# Warmup Iteration   1: 42925,340 ns/op
# Warmup Iteration   2: 47991,419 ns/op
# Warmup Iteration   3: 50854,318 ns/op
# Warmup Iteration   4: 51251,774 ns/op
# Warmup Iteration   5: 51756,902 ns/op
Iteration   1: 51102,960 ns/op
Iteration   2: 51420,802 ns/op
Iteration   3: 51744,142 ns/op
Iteration   4: 50985,401 ns/op
Iteration   5: 51125,197 ns/op
Iteration   6: 51223,229 ns/op
Iteration   7: 51424,190 ns/op
Iteration   8: 51457,326 ns/op
Iteration   9: 51410,258 ns/op
Iteration  10: 51419,014 ns/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.BlackholeConsumingBenchmark.forEachListBenchmark":
  51331,252 ±(99.9%) 335,358 ns/op [Average]
  (min, avg, max) = (50985,401, 51331,252, 51744,142), stdev = 221,819
  CI (99.9%): [50995,894, 51666,610] (assumes normal distribution)


# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: <none>
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.BlackholeConsumingBenchmark.forEachStreamBenchmark
# Parameters: (N = 1)

# Run progress: 50,00% complete, ETA 00:02:31
# Fork: 1 of 1
# Warmup Iteration   1: 25,963 ns/op
# Warmup Iteration   2: 20,840 ns/op
# Warmup Iteration   3: 18,882 ns/op
# Warmup Iteration   4: 19,081 ns/op
# Warmup Iteration   5: 19,513 ns/op
Iteration   1: 19,411 ns/op
Iteration   2: 18,856 ns/op
Iteration   3: 19,049 ns/op
Iteration   4: 18,891 ns/op
Iteration   5: 19,136 ns/op
Iteration   6: 20,116 ns/op
Iteration   7: 19,490 ns/op
Iteration   8: 19,251 ns/op
Iteration   9: 19,767 ns/op
Iteration  10: 19,607 ns/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.BlackholeConsumingBenchmark.forEachStreamBenchmark":
  19,357 ±(99.9%) 0,607 ns/op [Average]
  (min, avg, max) = (18,856, 19,357, 20,116), stdev = 0,401
  CI (99.9%): [18,751, 19,964] (assumes normal distribution)


# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: <none>
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.BlackholeConsumingBenchmark.forEachStreamBenchmark
# Parameters: (N = 10)

# Run progress: 60,00% complete, ETA 00:02:01
# Fork: 1 of 1
# Warmup Iteration   1: 59,828 ns/op
# Warmup Iteration   2: 52,901 ns/op
# Warmup Iteration   3: 44,941 ns/op
# Warmup Iteration   4: 44,833 ns/op
# Warmup Iteration   5: 44,962 ns/op
Iteration   1: 46,032 ns/op
Iteration   2: 45,802 ns/op
Iteration   3: 45,018 ns/op
Iteration   4: 45,704 ns/op
Iteration   5: 45,788 ns/op
Iteration   6: 46,674 ns/op
Iteration   7: 46,588 ns/op
Iteration   8: 48,083 ns/op
Iteration   9: 46,862 ns/op
Iteration  10: 47,087 ns/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.BlackholeConsumingBenchmark.forEachStreamBenchmark":
  46,364 ±(99.9%) 1,321 ns/op [Average]
  (min, avg, max) = (45,018, 46,364, 48,083), stdev = 0,874
  CI (99.9%): [45,042, 47,685] (assumes normal distribution)


# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: <none>
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.BlackholeConsumingBenchmark.forEachStreamBenchmark
# Parameters: (N = 100)

# Run progress: 70,00% complete, ETA 00:01:31
# Fork: 1 of 1
# Warmup Iteration   1: 382,038 ns/op
# Warmup Iteration   2: 347,846 ns/op
# Warmup Iteration   3: 337,712 ns/op
# Warmup Iteration   4: 335,078 ns/op
# Warmup Iteration   5: 344,895 ns/op
Iteration   1: 329,577 ns/op
Iteration   2: 328,436 ns/op
Iteration   3: 329,517 ns/op
Iteration   4: 330,736 ns/op
Iteration   5: 335,464 ns/op
Iteration   6: 338,727 ns/op
Iteration   7: 330,996 ns/op
Iteration   8: 330,809 ns/op
Iteration   9: 329,599 ns/op
Iteration  10: 330,580 ns/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.BlackholeConsumingBenchmark.forEachStreamBenchmark":
  331,444 ±(99.9%) 4,800 ns/op [Average]
  (min, avg, max) = (328,436, 331,444, 338,727), stdev = 3,175
  CI (99.9%): [326,645, 336,244] (assumes normal distribution)


# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: <none>
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.BlackholeConsumingBenchmark.forEachStreamBenchmark
# Parameters: (N = 1000)

# Run progress: 80,00% complete, ETA 00:01:00
# Fork: 1 of 1
# Warmup Iteration   1: 3734,819 ns/op
# Warmup Iteration   2: 3534,547 ns/op
# Warmup Iteration   3: 3201,812 ns/op
# Warmup Iteration   4: 3151,474 ns/op
# Warmup Iteration   5: 3136,897 ns/op
Iteration   1: 3138,505 ns/op
Iteration   2: 3137,993 ns/op
Iteration   3: 3141,723 ns/op
Iteration   4: 3225,711 ns/op
Iteration   5: 3127,945 ns/op
Iteration   6: 3129,312 ns/op
Iteration   7: 3141,355 ns/op
Iteration   8: 3137,377 ns/op
Iteration   9: 3149,419 ns/op
Iteration  10: 3243,662 ns/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.BlackholeConsumingBenchmark.forEachStreamBenchmark":
  3157,300 ±(99.9%) 62,671 ns/op [Average]
  (min, avg, max) = (3127,945, 3157,300, 3243,662), stdev = 41,453
  CI (99.9%): [3094,629, 3219,972] (assumes normal distribution)


# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: <none>
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.BlackholeConsumingBenchmark.forEachStreamBenchmark
# Parameters: (N = 10000)

# Run progress: 90,00% complete, ETA 00:00:30
# Fork: 1 of 1
# Warmup Iteration   1: 45988,758 ns/op
# Warmup Iteration   2: 45331,295 ns/op
# Warmup Iteration   3: 38213,299 ns/op
# Warmup Iteration   4: 31233,461 ns/op
# Warmup Iteration   5: 31321,451 ns/op
Iteration   1: 31470,793 ns/op
Iteration   2: 32267,081 ns/op
Iteration   3: 31619,772 ns/op
Iteration   4: 32155,094 ns/op
Iteration   5: 31304,547 ns/op
Iteration   6: 31484,244 ns/op
Iteration   7: 31709,801 ns/op
Iteration   8: 31297,118 ns/op
Iteration   9: 31305,782 ns/op
Iteration  10: 31320,821 ns/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.BlackholeConsumingBenchmark.forEachStreamBenchmark":
  31593,505 ±(99.9%) 537,786 ns/op [Average]
  (min, avg, max) = (31297,118, 31593,505, 32267,081), stdev = 355,712
  CI (99.9%): [31055,719, 32131,292] (assumes normal distribution)


# Run complete. Total time: 00:05:03

Benchmark                                             (N)  Mode  Cnt      Score     Error  Units
BlackholeConsumingBenchmark.forEachListBenchmark        1  avgt   10      6,703 ±   0,230  ns/op
BlackholeConsumingBenchmark.forEachListBenchmark       10  avgt   10     50,719 ±   1,138  ns/op
BlackholeConsumingBenchmark.forEachListBenchmark      100  avgt   10    566,605 ±  11,369  ns/op
BlackholeConsumingBenchmark.forEachListBenchmark     1000  avgt   10   4854,645 ±  40,238  ns/op
BlackholeConsumingBenchmark.forEachListBenchmark    10000  avgt   10  51331,252 ± 335,358  ns/op
BlackholeConsumingBenchmark.forEachStreamBenchmark      1  avgt   10     19,357 ±   0,607  ns/op
BlackholeConsumingBenchmark.forEachStreamBenchmark     10  avgt   10     46,364 ±   1,321  ns/op
BlackholeConsumingBenchmark.forEachStreamBenchmark    100  avgt   10    331,444 ±   4,800  ns/op
BlackholeConsumingBenchmark.forEachStreamBenchmark   1000  avgt   10   3157,300 ±  62,671  ns/op
BlackholeConsumingBenchmark.forEachStreamBenchmark  10000  avgt   10  31593,505 ± 537,786  ns/op

И становится интереснее: разница между ArrayList.forEach() и ArrayList.stream().forEach() получилась достаточно большой на длинных списках. Более того, прогрев никак не ускоряет ArrayList.forEach(), тогда как ArrayList.stream().forEach() заметно ускоряется.

Дело в том, что накладные расходы на создание Stream оказывают влияние лишь на списках малого размера. В дальнейшем всё сводится к непосредственному итерированию.

Так выглядит ArrayList.forEach():

    public void forEach(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        final int expectedModCount = modCount;
        @SuppressWarnings("unchecked")
        final E[] elementData = (E[]) this.elementData;
        final int size = this.size;
        for (int i=0; modCount == expectedModCount && i < size; i++) {
            action.accept(elementData[i]);
        }
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

Так выглядит код ArrayList.ArrayListSpliterator.forEachRemaining():

        public void forEachRemaining(Consumer<? super E> action) {
            int i, hi, mc; // hoist accesses and checks from loop
            ArrayList<E> lst; Object[] a;
            if (action == null)
                throw new NullPointerException();
            if ((lst = list) != null && (a = lst.elementData) != null) {
                if ((hi = fence) < 0) {
                    mc = lst.modCount;
                    hi = lst.size;
                }
                else
                    mc = expectedModCount;
                if ((i = index) >= 0 && (index = hi) <= a.length) {
                    for (; i < hi; ++i) {
                        @SuppressWarnings("unchecked") E e = (E) a[i];
                        action.accept(e);
                    }
                    if (lst.modCount == mc)
                        return;
                }
            }
            throw new ConcurrentModificationException();
        }

Как видим, разница в коде не существенная (циклы for внутри методов): дальше в дело вступает JIT-компилятор. Андрей apangin помог разобраться в чём тут дело: Blackhole.consume() не инлайнится и JIT-компилятор не может как следует оптимизировать код: в итоге остаётся и чтение поля modCount, и проверка границ массива.

Действительно, попробуем заменить Blackhole.consume() на свой самопальный метод:

Бенчмарк с другим потребителем значений

package ru.gnkoshelev.jbreak2018.perf_tests.for_each;

@Fork(value = 1, warmups = 0)
@Warmup(iterations = 5, time = 2_000, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 10, time = 2_000, timeUnit = TimeUnit.MILLISECONDS)
@OutputTimeUnit(value = TimeUnit.NANOSECONDS)
@BenchmarkMode(Mode.AverageTime)
@State(Scope.Benchmark)
public class TrickyConsumingBenchmark {
    @Param(value = {"100", "10000"})
    public int N;

    private List<Integer> values;

    @Setup
    public void setup() {
        Random rand = new Random(12345);

        int size = N;
        values = new ArrayList<>();

        for (int i = 0; i < size; i++) {
            values.add(rand.nextInt());
        }
    }

    @Benchmark
    public void forEachListBenchmark() {
        forEachList(values);
    }

    @Benchmark
    public void forEachStreamBenchmark() {
        forEachStream(values);
    }

    public void forEachList(List<Integer> values) {
        values.forEach(TrickyConsumer::consume);
    }

    public void forEachStream(List<Integer> values) {
        values.stream().forEach(TrickyConsumer::consume);
    }

    public static class TrickyConsumer {
        public static Integer value;

        public static void consume(Integer value) {
            if (! (value % 100 == 0)) {
                TrickyConsumer.value = value;
            }
        }
    }
}

Результаты

# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: <none>
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.TrickyConsumingBenchmark.forEachListBenchmark
# Parameters: (N = 100)

# Run progress: 0,00% complete, ETA 00:02:00
# Fork: 1 of 1
# Warmup Iteration   1: 205,489 ns/op
# Warmup Iteration   2: 205,514 ns/op
# Warmup Iteration   3: 216,056 ns/op
# Warmup Iteration   4: 208,956 ns/op
# Warmup Iteration   5: 204,900 ns/op
Iteration   1: 205,535 ns/op
Iteration   2: 210,834 ns/op
Iteration   3: 206,050 ns/op
Iteration   4: 205,962 ns/op
Iteration   5: 205,285 ns/op
Iteration   6: 205,581 ns/op
Iteration   7: 204,991 ns/op
Iteration   8: 209,290 ns/op
Iteration   9: 203,927 ns/op
Iteration  10: 204,977 ns/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.TrickyConsumingBenchmark.forEachListBenchmark":
  206,243 ±(99.9%) 3,222 ns/op [Average]
  (min, avg, max) = (203,927, 206,243, 210,834), stdev = 2,131
  CI (99.9%): [203,021, 209,465] (assumes normal distribution)


# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: <none>
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.TrickyConsumingBenchmark.forEachListBenchmark
# Parameters: (N = 10000)

# Run progress: 25,00% complete, ETA 00:01:30
# Fork: 1 of 1
# Warmup Iteration   1: 22733,300 ns/op
# Warmup Iteration   2: 22197,064 ns/op
# Warmup Iteration   3: 21640,616 ns/op
# Warmup Iteration   4: 21411,160 ns/op
# Warmup Iteration   5: 21702,499 ns/op
Iteration   1: 21921,831 ns/op
Iteration   2: 21970,321 ns/op
Iteration   3: 21409,419 ns/op
Iteration   4: 21171,131 ns/op
Iteration   5: 22011,961 ns/op
Iteration   6: 22063,926 ns/op
Iteration   7: 21825,015 ns/op
Iteration   8: 21820,783 ns/op
Iteration   9: 22089,657 ns/op
Iteration  10: 21626,934 ns/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.TrickyConsumingBenchmark.forEachListBenchmark":
  21791,098 ±(99.9%) 456,511 ns/op [Average]
  (min, avg, max) = (21171,131, 21791,098, 22089,657), stdev = 301,954
  CI (99.9%): [21334,587, 22247,609] (assumes normal distribution)


# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: <none>
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.TrickyConsumingBenchmark.forEachStreamBenchmark
# Parameters: (N = 100)

# Run progress: 50,00% complete, ETA 00:01:00
# Fork: 1 of 1
# Warmup Iteration   1: 250,480 ns/op
# Warmup Iteration   2: 247,070 ns/op
# Warmup Iteration   3: 269,745 ns/op
# Warmup Iteration   4: 269,914 ns/op
# Warmup Iteration   5: 272,912 ns/op
Iteration   1: 269,779 ns/op
Iteration   2: 270,502 ns/op
Iteration   3: 269,128 ns/op
Iteration   4: 273,862 ns/op
Iteration   5: 275,447 ns/op
Iteration   6: 272,090 ns/op
Iteration   7: 271,189 ns/op
Iteration   8: 271,714 ns/op
Iteration   9: 269,121 ns/op
Iteration  10: 269,913 ns/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.TrickyConsumingBenchmark.forEachStreamBenchmark":
  271,275 ±(99.9%) 3,144 ns/op [Average]
  (min, avg, max) = (269,121, 271,275, 275,447), stdev = 2,079
  CI (99.9%): [268,131, 274,418] (assumes normal distribution)


# JMH version: 1.20
# VM version: JDK 1.8.0_161, VM 25.161-b12
# VM invoker: C:Program FilesJavajre1.8.0_161binjava.exe
# VM options: <none>
# Warmup: 5 iterations, 2000 ms each
# Measurement: 10 iterations, 2000 ms each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: ru.gnkoshelev.jbreak2018.perf_tests.for_each.TrickyConsumingBenchmark.forEachStreamBenchmark
# Parameters: (N = 10000)

# Run progress: 75,00% complete, ETA 00:00:30
# Fork: 1 of 1
# Warmup Iteration   1: 22612,079 ns/op
# Warmup Iteration   2: 24943,260 ns/op
# Warmup Iteration   3: 23366,453 ns/op
# Warmup Iteration   4: 23445,251 ns/op
# Warmup Iteration   5: 23732,635 ns/op
Iteration   1: 23575,011 ns/op
Iteration   2: 23478,581 ns/op
Iteration   3: 23663,154 ns/op
Iteration   4: 23067,535 ns/op
Iteration   5: 23489,020 ns/op
Iteration   6: 23461,241 ns/op
Iteration   7: 23510,542 ns/op
Iteration   8: 23504,541 ns/op
Iteration   9: 24036,074 ns/op
Iteration  10: 24081,512 ns/op


Result "ru.gnkoshelev.jbreak2018.perf_tests.for_each.TrickyConsumingBenchmark.forEachStreamBenchmark":
  23586,721 ±(99.9%) 442,736 ns/op [Average]
  (min, avg, max) = (23067,535, 23586,721, 24081,512), stdev = 292,843
  CI (99.9%): [23143,985, 24029,458] (assumes normal distribution)


# Run complete. Total time: 00:02:01

Benchmark                                          (N)  Mode  Cnt      Score     Error  Units
TrickyConsumingBenchmark.forEachListBenchmark      100  avgt   10    206,243 ±   3,222  ns/op
TrickyConsumingBenchmark.forEachListBenchmark    10000  avgt   10  21791,098 ± 456,511  ns/op
TrickyConsumingBenchmark.forEachStreamBenchmark    100  avgt   10    271,275 ±   3,144  ns/op
TrickyConsumingBenchmark.forEachStreamBenchmark  10000  avgt   10  23586,721 ± 442,736  ns/op

Всё вернулось на круги своя, а как уж тут отработал JIT — совсем другая история.

Выводы

1. Какой же в итоге правильный ответ? методы 1 и 2 в задаче дают незначительно отличающиеся результаты, а метод 3 значительно уступает в производительности.

2. В качестве правильно ответа принимались альтернативные варианты, что 1 быстрее 2 и 2 быстрее 1, если это было верно аргументировано.

3. Личный вывод: кроличья нора оказывается всегда глубже, чем думаешь.

Код бенчмарков можно взять на github: jbreak2018-forEach-perf-tests.

Статистика

Из 32 сданных вариантов было 8 правильных и 5 частично правильных. Ещё 7 человек попали в PrintStream-ловушку, посчитав параллельный Stream самым быстрым. Никто не поверил в последовательные стримы и не выбрал вариант 2 в качестве самого быстрого.

P.S.

Следующую часть постараюсь подготовить на следующих выходных.

Автор: Григорий Кошелев

Источник

Поделиться

* - обязательные к заполнению поля