В 2021 году я выложил короткий сниппет про оптимизацию цикла. Идея старая как мир: вместо for (i = 0; i < n; i++) крутить счётчик в обратную сторону, до нуля. Я проверял это на J2ME-приложении, запущенном на настоящем телефоне Nokia, и обратный цикл стабильно выигрывал около 12%.

С тех пор этот приём регулярно всплывает в код-ревью и в чатах как «бесплатное ускорение». Я решил проверить, осталось ли от него что-то в 2026 году. Взял тот же код и его аналоги и прогнал в девяти средах выполнения: Java 21 в трёх режимах, Node.js, Bun, Chromium, PHP 8.3 с JIT и без, Python 3.13, C (gcc и clang на разных уровнях оптимизации) и Go.

Все цифры ниже — мои собственные замеры, кроме данных с Nokia, которые взяты из того самого сниппета. Как мерил, описано в разделе «Методика». В конце статьи есть бенчмарк, который можно запустить прямо в своём браузере.

Коротко:

  1. Обратный цикл выигрывает только там, где код исполняется буквально: в интерпретаторе байткода Java (до 31%), в C без оптимизаций (-O0, 7–13%) и на старом телефоне (12%).
  2. Как только включается оптимизирующий компилятор, выигрыш пропадает. В HotSpot C2, gcc -O2/-O3, Go и PHP с JIT разница в пределах шума.
  3. Часто обратный цикл медленнее. В V8, JavaScriptCore и clang он проигрывает 5–46%, а в Java 21 на суммировании массива — 37%, потому что компилятор хуже векторизует обход с конца.
  4. Короткая запись for (i = n; i--;) в JavaScript — самая медленная из всех вариантов с индексом во всех трёх движках.
  5. Направление цикла почти никогда не главное. count() в условии цикла в PHP, sum() вместо ручного цикла в Python и правильный прогрев в JS-бенчмарке меняют результат сильнее.

§Откуда взялась эта оптимизация

Вот исходный тест из сниппета. Это MIDlet для J2ME: два пустых цикла по 9 миллионов итераций, время меряется через System.currentTimeMillis().

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
long start, end;

/* Обычный цикл */
start = System.currentTimeMillis();
for (int i = 0; i < 9000000; i++) {
  /* do something */
}
end = System.currentTimeMillis();
System.out.println("Normal loop: " + (end - start) + " milliseconds");

/* Обратный цикл */
start = System.currentTimeMillis();
for (int i = 8999999; i >= 0; i--) {
  /* do something */
}
end = System.currentTimeMillis();
System.out.println("Optimized loop: " + (end - start) + " milliseconds");

Чтобы понять, почему второй цикл быстрее, достаточно посмотреть на байткод. Я скомпилировал оба цикла javac из JDK 21 и разобрал javap -c. На каждой итерации обычный цикл выполняет пять инструкций, обратный — четыре:

1
2
3
4
5
6
// for (int i = 0; i < 9000000; i++)      // for (int i = 8999999; i >= 0; i--)
iload_1                                   iload_1
ldc  #7  // int 9000000                   iflt  выход
if_icmpge  выход                          iinc  1, -1
iinc  1, 1                                goto  начало
goto  начало

Обычный цикл на каждом шаге загружает константу 9 000 000 из пула констант (ldc) и сравнивает два числа (if_icmpge). Обратный сравнивает счётчик с нулём одной инструкцией iflt: в JVM есть отдельные инструкции для сравнения с нулём, им не нужен второй операнд. То же самое происходит в процессоре: после декремента флаги уже выставлены, и отдельное сравнение с нулём часто не нужно.

Обычный циклОбратный цикл
Инструкций байткода на итерацию54
Сравнениеldc + if_icmpge (два операнда)iflt (сравнение с нулём)
Ожидаемый выигрыш в интерпретаторе—до 20% по числу инструкций

Интерпретатор исполняет инструкции по одной, поэтому минус одна инструкция из пяти — это заметный выигрыш. Именно так работала Java-машина на кнопочных телефонах. Вопрос в том, что происходит, когда между байткодом и процессором стоит оптимизирующий компилятор.

§Что показала Nokia в 2021 году

Вот исходные замеры с телефона: 11 запусков, в каждом сначала обычный, затем обратный цикл. Наведите курсор на график, чтобы увидеть значения.

Nokia, J2ME: время цикла на 9 млн итераций, мс

Обычный циклОбратный циклРазница
Медиана, мс46604114−11,7%
Лучший запуск, мс45493963−12,9%
Худший запуск, мс62515129−17,9%

В 10 запусках из 11 обратный цикл был быстрее. Один раз (запуск 10) он проиграл, скорее всего из-за фоновой активности телефона. Модель телефона в сниппете не записана, поэтому я сравниваю только направление и порядок эффекта, а не абсолютные миллисекунды.

§Методика

Все новые замеры я делал на одной машине: облачная виртуалка на Intel Xeon 2,8 ГГц, 4 vCPU, Ubuntu 24.04. Виртуалка шумная, поэтому:

  • каждый бенчмарк запускался в нескольких отдельных процессах (5 для Java, Node, Bun и Chromium, 3 для PHP и Python, 15 повторов go test);
  • перед замером был прогрев, чтобы JIT успел скомпилировать код;
  • порядок вариантов чередовался от раунда к раунду, чтобы дрейф частоты процессора не играл в пользу одного из них;
  • в таблицах указана медиана, а не среднее: единичные выбросы на виртуалке случаются постоянно.

Разницу меньше 3–5% я считаю шумом. Ниже минус значит, что обратный цикл быстрее, плюс — что медленнее.

Нагрузка везде одна и та же: сумма элементов массива из 1 млн целых чисел (в Java — 9 млн, как в исходном тесте), плюс для Java отдельно исходный пустой цикл и цикл, суммирующий счётчик. Тело цикла нужно, чтобы компилятор не выбросил цикл целиком. Почему это важно, видно в следующем разделе.

§Java 21: интерпретатор, C1 и C2

Сначала я запустил исходный код из сниппета как есть, на HotSpot из OpenJDK 21. После нескольких повторов оба пустых цикла стали занимать 0 микросекунд. JIT-компилятор C2 видит, что цикл ничего не делает, и удаляет его. Сравнивать там уже нечего: обычный пустой цикл и обратный пустой цикл одинаково бесплатны.

Чтобы цикл не исчезал, я добавил в тело суммирование: в одном варианте суммируется сам счётчик, в другом — элементы массива int[9_000_000].

1
2
3
4
5
6
7
// Счётчик: тело зависит от i, цикл нельзя выбросить
static long countForward() { long s = 0; for (int i = 0; i < N; i++) s += i; return s; }
static long countReverse() { long s = 0; for (int i = N - 1; i >= 0; i--) s += i; return s; }

// Массив: граница читается из a.length
static long arrForward(int[] a) { long s = 0; for (int i = 0; i < a.length; i++) s += a[i]; return s; }
static long arrReverse(int[] a) { long s = 0; for (int i = a.length - 1; i >= 0; i--) s += a[i]; return s; }

Каждый вариант я прогнал в трёх режимах HotSpot: -Xint (только интерпретатор, ближе всего к старым телефонам), -XX:TieredStopAtLevel=1 (только быстрый компилятор C1) и режим по умолчанию с C2.

Режим JVMТестОбычный, мсОбратный, мсРазница
-Xintпустой цикл54,737,7−31%
-Xintсумма счётчика98,772,7−26%
-Xintсумма массива128,8102,1−21%
C1сумма счётчика5,585,48−2%
C1сумма массива8,859,49+7%
C2 (по умолчанию)пустой цикл00—
C2 (по умолчанию)сумма счётчика2,962,99+1%
C2 (по умолчанию)сумма массива4,115,64+37%

В интерпретаторе обратный цикл выигрывает даже больше, чем на Nokia: те же четыре инструкции вместо пяти. Компилятор C1 уже сглаживает разницу до шума. А C2 на обходе массива делает обратный цикл заметно медленнее.

Причина — автовекторизация. C2 умеет обрабатывать несколько элементов массива за одну инструкцию процессора (оптимизация SuperWord), и прямой обход он векторизует лучше. Когда я отключил её флагом -XX:-UseSuperWord, разрыв сократился с 37% до 8% (4,90 мс против 5,30 мс). То есть «оптимизация» мешает компилятору применить настоящую оптимизацию.

§JavaScript: V8 и JavaScriptCore

В JavaScript я сравнил восемь способов обойти массив из миллиона чисел: два прямых цикла с индексом, три обратных и три способа без индекса.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
// Прямые
for (let i = 0; i < a.length; i++) s += a[i];
for (let i = 0, n = a.length; i < n; i++) s += a[i];

// Обратные
for (let i = a.length - 1; i >= 0; i--) s += a[i];
for (let i = a.length; i--;) s += a[i];      // та самая «оптимизация»
let i = a.length; while (i--) s += a[i];

// Без индекса
for (const v of a) s += v;
a.forEach((v) => { s += v; });
a.reduce((s, v) => s + v, 0);

Замеры в трёх движках: Node.js 22 (V8 12.4), Bun 1.4 (JavaScriptCore) и Chromium 153 (свежий V8, запуск через Playwright). Переключайте движок кнопками над графиком. Оранжевым отмечены обратные циклы, синим — прямые, серым — варианты без индекса.

Сумма массива из 1 млн чисел, мс (меньше — лучше)

ВариантNode.js 22, мсBun 1.4, мсChromium 153, мс
for i++0,800,600,59
for i++ (длина в переменной)0,810,590,56
for i-- (i >= 0)0,850,700,70
for (i = n; i--;)1,070,830,86
while (i--)1,040,810,86
for...of1,071,820,73
forEach3,301,473,64
reduce0,810,850,62

Во всех трёх движках обратный цикл медленнее прямого. Аккуратная запись с i >= 0 проигрывает 5–19%, а короткая for (i = n; i--;) и while (i--) — 29–46%. Я не разбирал машинный код, который генерируют V8 и JavaScriptCore, поэтому не буду утверждать, в чём именно дело. Факт в том, что в 2026 году «оптимизированный» цикл в JavaScript медленнее обычного.

Ещё один вывод: кешировать длину массива в переменную n больше не нужно. Разница с i < a.length в пределах шума во всех движках.

§Ловушка прогрева

Первая версия этого бенчмарка показала, что for...of, forEach и reduce в V8 медленнее обычного цикла в 10 раз. Оказалось, что это ошибка измерения. Каждая функция начинала работать сразу на миллионе элементов, и V8 оптимизировал её только частично, прямо посреди выполнения цикла (это называется OSR, on-stack replacement). Такой код намного медленнее полностью оптимизированного.

Когда я сначала прогрел каждую функцию 20 000 раз на массиве из 1000 элементов, for...of в Node.js ускорился с 11 мс до 1,07 мс, а reduce — с 8,5 мс до 0,81 мс. Разница в 10 раз появилась из-за способа измерения, а не из-за кода. Это хорошая иллюстрация того, почему микробенчмаркам в JavaScript нельзя верить без прогрева.

§PHP 8.3: с JIT и без

В PHP я дополнительно проверил классическую ошибку — count() в условии цикла, который вызывается на каждой итерации.

1
2
3
4
5
6
for ($i = 0; $i < count($a); $i++) $s += $a[$i];        // count() на каждом шаге
for ($i = 0, $n = count($a); $i < $n; $i++) $s += $a[$i];
for ($i = count($a) - 1; $i >= 0; $i--) $s += $a[$i];
$i = count($a); while ($i--) $s += $a[$i];
foreach ($a as $v) $s += $v;
array_sum($a);
ВариантPHP 8.3, без JIT, мсPHP 8.3, tracing JIT, мс
for + count() в условии14,383,30
for + длина в переменной10,793,27
for i-- (>= 0)12,473,40
while ($i--)12,213,43
foreach8,993,50
array_sum()2,752,60

Без JIT обратный цикл не быстрее прямого с длиной в переменной (на этой виртуалке даже медленнее, хотя разброс между запусками большой). Реальные выигрыши здесь другие: вынести count() из условия (−25%), перейти на foreach (ещё −17%) и, если нужна просто сумма, вызвать array_sum(), который в 3–5 раз быстрее любого цикла. С включённым JIT (opcache.jit=tracing) все варианты цикла укладываются в 3,3–3,5 мс.

§Python 3.13

ВариантВремя, мс
for i in range(len(a))38,4
for i in range(len(a) - 1, -1, -1)39,1
while i: i -= 152,6
for v in a23,9
for v in reversed(a)25,7
sum(a)9,6

В Python направление цикла ничего не меняет: обратный range в пределах шума от прямого. Ручной while с декрементом медленнее на 37%, потому что каждое действие со счётчиком — отдельная операция интерпретатора. Обход без индекса быстрее индексного на 38%, а встроенный sum() быстрее индексного цикла в 4 раза.

§C: gcc и clang

В C разница зависит только от уровня оптимизации.

КомпиляторПрямой, мсОбратный, мсwhile (i--), мсРазница
gcc 13 -O03,092,692,72−13%
clang 18 -O02,612,422,36−7%
gcc 13 -O20,660,660,660%
gcc 13 -O30,350,360,37+2%
clang 18 -O20,430,590,59+37%
clang 18 -O30,360,490,49+34%

Без оптимизаций (-O0) компилятор переводит код почти дословно, и обратный цикл выигрывает так же, как в интерпретаторе Java. С -O2 картина меняется. Вот что gcc генерирует для обоих циклов:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
; прямой цикл: for (int i = 0; i < n; i++) s += a[i];
.L3:
    movslq  (%rdi), %rdx      ; загрузить a[i]
    addq    $4, %rdi          ; сдвинуть указатель
    addq    %rdx, %rax        ; s += a[i]
    cmpq    %rcx, %rdi        ; дошли до конца массива?
    jne     .L3

; обратный цикл: for (int i = n - 1; i >= 0; i--) s += a[i];
.L9:
    movslq  (%rdi,%rsi,4), %rdx
    subq    $1, %rsi
    addq    %rdx, %rax
    testl   %esi, %esi
    jns     .L9

В обоих циклах по пять инструкций. Компилятор сам переписал прямой цикл на обход указателем до конца массива, и сравнения с n в нём больше нет. Ручная «оптимизация» здесь ничего не даёт: компилятор уже сделал лучше.

clang на -O2 векторизует оба цикла, то есть складывает по несколько чисел за инструкцию. Но в обратном цикле ему приходится разворачивать порядок элементов в каждом векторе дополнительными инструкциями pshufd. Для суммы порядок не важен, а компилятор его всё равно сохраняет, и обратный цикл проигрывает 34–37%.

§Go 1.24

1
2
3
for i := 0; i < len(a); i++ { s += int64(a[i]) }
for i := len(a) - 1; i >= 0; i-- { s += int64(a[i]) }
for _, v := range a { s += int64(v) }
ВариантМедиана, мсЛучший запуск, мс
прямой for0,7150,629
обратный for0,7340,614
range0,7140,617

В Go разницы нет: медианы и лучшие запуски всех трёх вариантов в пределах шума.

§Сводная картина

На графике — насколько обратный цикл быстрее или медленнее прямого в каждой среде. Полоса влево и оранжевая — обратный цикл выигрывает, вправо и синяя — проигрывает. Серым отмечена разница меньше 3%, это шум.

Обратный цикл относительно прямого, %

СредаОбычныйОбратныйРазница
Nokia, J2ME (2021)4660 мс4114 мс−11,7%
Java 21, -Xint, пустой цикл54,7 мс37,7 мс−31%
Java 21, -Xint, сумма массива128,8 мс102,1 мс−21%
C, gcc -O03,09 мс2,69 мс−13%
C, clang -O02,61 мс2,42 мс−7%
Java 21, C2, сумма счётчика2,96 мс2,99 мс+1%
C, gcc -O20,66 мс0,66 мс0%
Go 1.240,715 мс0,734 мс+3%
Python 3.1338,4 мс39,1 мс+2%
PHP 8.3, JIT3,27 мс3,40 мс+4%
Node.js 220,80 мс0,85 мс+5%
PHP 8.3, без JIT10,79 мс12,47 мс+16%
Bun 1.40,60 мс0,70 мс+16%
Chromium 1530,59 мс0,70 мс+19%
C, clang -O20,43 мс0,59 мс+37%
Java 21, C2, сумма массива4,11 мс5,64 мс+37%

Закономерность простая. Обратный цикл выигрывает там, где код исполняется так, как написан: в интерпретаторе байткода и в C без оптимизаций. Как только между кодом и процессором появляется оптимизирующий компилятор, выигрыш исчезает, а иногда превращается в проигрыш.

§Запустите бенчмарк у себя

Ниже — тот же набор JavaScript-вариантов, что и в разделе про V8. Код выполняется в вашем браузере, никуда ничего не отправляется. Прогрев и замер занимают несколько секунд, на слабом телефоне — дольше. Результаты будут отличаться от моих: другой процессор, другой движок, другая нагрузка на систему. Интересно посмотреть, как ведут себя Firefox и Safari, которые я не проверял.

Ваш браузер: сумма массива из 1 млн чисел, мс

Нажмите кнопку, чтобы начать

§Когда обратный цикл всё-таки нужен

Ради скорости — почти никогда. Но у обхода с конца есть причины, не связанные с производительностью:

  • Удаление элементов во время обхода. Если удалять элементы массива по индексу (splice в JavaScript, remove в Java), при прямом обходе индексы следующих элементов сдвигаются, и цикл пропускает элементы. При обходе с конца сдвигаются только уже обработанные.
  • Живые коллекции DOM. getElementsByClassName возвращает живую HTMLCollection: если удалить из DOM элемент или снять с него класс, коллекция изменится прямо во время обхода. Обход с конца решает ту же проблему.
  • Код без оптимизирующего компилятора. J2ME, интерпретатор Java без JIT, отладочные сборки C. Если вы пишете под такую платформу, замеры выше говорят, что выигрыш реальный.
1
2
3
4
5
6
7
// Удаляем все отрицательные числа: обход с конца не пропускает элементы
for (let i = arr.length - 1; i >= 0; i--) {
  if (arr[i] < 0) arr.splice(i, 1);
}

// Хотя обычно проще и быстрее создать новый массив
const positive = arr.filter((x) => x >= 0);

§Итог

Обратный цикл был честной оптимизацией для эпохи, когда байткод исполнялся инструкция за инструкцией. На Nokia он давал 12%, и в интерпретаторе Java 21 до сих пор даёт 21–31%. Но в 2026 году почти любой код проходит через оптимизирующий компилятор, а компилятор лучше нас знает, как сравнивать счётчик и в каком порядке обходить память. В V8, JavaScriptCore, clang и HotSpot C2 обратный цикл работает медленнее обычного, иногда на треть.

Если хочется ускорить цикл, сначала стоит проверить другое: не вызывается ли в условии функция вроде count(), нет ли встроенной функции, которая делает то же самое (array_sum, sum), и правильно ли прогрет бенчмарк. А направление цикла лучше выбирать по смыслу задачи и писать так, как проще читать.

Исходный сниппет 2021 года: For loop optimizing. Инструкции байткода, о которых шла речь, описаны в спецификации JVM, глава 6.