В 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, которые взяты из того самого сниппета. Как мерил, описано в разделе «Методика». В конце статьи есть бенчмарк, который можно запустить прямо в своём браузере.
Коротко:
- Обратный цикл выигрывает только там, где код исполняется буквально: в интерпретаторе байткода Java (до 31%), в C без оптимизаций (
-O0, 7–13%) и на старом телефоне (12%). - Как только включается оптимизирующий компилятор, выигрыш пропадает. В HotSpot C2, gcc
-O2/-O3, Go и PHP с JIT разница в пределах шума. - Часто обратный цикл медленнее. В V8, JavaScriptCore и clang он проигрывает 5–46%, а в Java 21 на суммировании массива — 37%, потому что компилятор хуже векторизует обход с конца.
- Короткая запись
for (i = n; i--;)в JavaScript — самая медленная из всех вариантов с индексом во всех трёх движках. - Направление цикла почти никогда не главное.
count()в условии цикла в PHP,sum()вместо ручного цикла в Python и правильный прогрев в JS-бенчмарке меняют результат сильнее.
§Откуда взялась эта оптимизация
Вот исходный тест из сниппета. Это MIDlet для J2ME: два пустых цикла по 9 миллионов итераций, время меряется через System.currentTimeMillis().
| |
Чтобы понять, почему второй цикл быстрее, достаточно посмотреть на байткод. Я скомпилировал оба цикла javac из JDK 21 и разобрал javap -c. На каждой итерации обычный цикл выполняет пять инструкций, обратный — четыре:
| |
Обычный цикл на каждом шаге загружает константу 9 000 000 из пула констант (ldc) и сравнивает два числа (if_icmpge). Обратный сравнивает счётчик с нулём одной инструкцией iflt: в JVM есть отдельные инструкции для сравнения с нулём, им не нужен второй операнд. То же самое происходит в процессоре: после декремента флаги уже выставлены, и отдельное сравнение с нулём часто не нужно.
| Обычный цикл | Обратный цикл | |
|---|---|---|
| Инструкций байткода на итерацию | 5 | 4 |
| Сравнение | ldc + if_icmpge (два операнда) | iflt (сравнение с нулём) |
| Ожидаемый выигрыш в интерпретаторе | — | до 20% по числу инструкций |
Интерпретатор исполняет инструкции по одной, поэтому минус одна инструкция из пяти — это заметный выигрыш. Именно так работала Java-машина на кнопочных телефонах. Вопрос в том, что происходит, когда между байткодом и процессором стоит оптимизирующий компилятор.
§Что показала Nokia в 2021 году
Вот исходные замеры с телефона: 11 запусков, в каждом сначала обычный, затем обратный цикл. Наведите курсор на график, чтобы увидеть значения.
Nokia, J2ME: время цикла на 9 млн итераций, мс
| Обычный цикл | Обратный цикл | Разница | |
|---|---|---|---|
| Медиана, мс | 4660 | 4114 | −11,7% |
| Лучший запуск, мс | 4549 | 3963 | −12,9% |
| Худший запуск, мс | 6251 | 5129 | −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].
| |
Каждый вариант я прогнал в трёх режимах HotSpot: -Xint (только интерпретатор, ближе всего к старым телефонам), -XX:TieredStopAtLevel=1 (только быстрый компилятор C1) и режим по умолчанию с C2.
| Режим JVM | Тест | Обычный, мс | Обратный, мс | Разница |
|---|---|---|---|---|
-Xint | пустой цикл | 54,7 | 37,7 | −31% |
-Xint | сумма счётчика | 98,7 | 72,7 | −26% |
-Xint | сумма массива | 128,8 | 102,1 | −21% |
| C1 | сумма счётчика | 5,58 | 5,48 | −2% |
| C1 | сумма массива | 8,85 | 9,49 | +7% |
| C2 (по умолчанию) | пустой цикл | 0 | 0 | — |
| C2 (по умолчанию) | сумма счётчика | 2,96 | 2,99 | +1% |
| C2 (по умолчанию) | сумма массива | 4,11 | 5,64 | +37% |
В интерпретаторе обратный цикл выигрывает даже больше, чем на Nokia: те же четыре инструкции вместо пяти. Компилятор C1 уже сглаживает разницу до шума. А C2 на обходе массива делает обратный цикл заметно медленнее.
Причина — автовекторизация. C2 умеет обрабатывать несколько элементов массива за одну инструкцию процессора (оптимизация SuperWord), и прямой обход он векторизует лучше. Когда я отключил её флагом -XX:-UseSuperWord, разрыв сократился с 37% до 8% (4,90 мс против 5,30 мс). То есть «оптимизация» мешает компилятору применить настоящую оптимизацию.
§JavaScript: V8 и JavaScriptCore
В JavaScript я сравнил восемь способов обойти массив из миллиона чисел: два прямых цикла с индексом, три обратных и три способа без индекса.
| |
Замеры в трёх движках: 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,80 | 0,60 | 0,59 |
for i++ (длина в переменной) | 0,81 | 0,59 | 0,56 |
for i-- (i >= 0) | 0,85 | 0,70 | 0,70 |
for (i = n; i--;) | 1,07 | 0,83 | 0,86 |
while (i--) | 1,04 | 0,81 | 0,86 |
for...of | 1,07 | 1,82 | 0,73 |
forEach | 3,30 | 1,47 | 3,64 |
reduce | 0,81 | 0,85 | 0,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() в условии цикла, который вызывается на каждой итерации.
| |
| Вариант | PHP 8.3, без JIT, мс | PHP 8.3, tracing JIT, мс |
|---|---|---|
for + count() в условии | 14,38 | 3,30 |
for + длина в переменной | 10,79 | 3,27 |
for i-- (>= 0) | 12,47 | 3,40 |
while ($i--) | 12,21 | 3,43 |
foreach | 8,99 | 3,50 |
array_sum() | 2,75 | 2,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 -= 1 | 52,6 |
for v in a | 23,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 -O0 | 3,09 | 2,69 | 2,72 | −13% |
clang 18 -O0 | 2,61 | 2,42 | 2,36 | −7% |
gcc 13 -O2 | 0,66 | 0,66 | 0,66 | 0% |
gcc 13 -O3 | 0,35 | 0,36 | 0,37 | +2% |
clang 18 -O2 | 0,43 | 0,59 | 0,59 | +37% |
clang 18 -O3 | 0,36 | 0,49 | 0,49 | +34% |
Без оптимизаций (-O0) компилятор переводит код почти дословно, и обратный цикл выигрывает так же, как в интерпретаторе Java. С -O2 картина меняется. Вот что gcc генерирует для обоих циклов:
| |
В обоих циклах по пять инструкций. Компилятор сам переписал прямой цикл на обход указателем до конца массива, и сравнения с n в нём больше нет. Ручная «оптимизация» здесь ничего не даёт: компилятор уже сделал лучше.
clang на -O2 векторизует оба цикла, то есть складывает по несколько чисел за инструкцию. Но в обратном цикле ему приходится разворачивать порядок элементов в каждом векторе дополнительными инструкциями pshufd. Для суммы порядок не важен, а компилятор его всё равно сохраняет, и обратный цикл проигрывает 34–37%.
§Go 1.24
| |
| Вариант | Медиана, мс | Лучший запуск, мс |
|---|---|---|
прямой for | 0,715 | 0,629 |
обратный for | 0,734 | 0,614 |
range | 0,714 | 0,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 -O0 | 3,09 мс | 2,69 мс | −13% |
C, clang -O0 | 2,61 мс | 2,42 мс | −7% |
| Java 21, C2, сумма счётчика | 2,96 мс | 2,99 мс | +1% |
C, gcc -O2 | 0,66 мс | 0,66 мс | 0% |
| Go 1.24 | 0,715 мс | 0,734 мс | +3% |
| Python 3.13 | 38,4 мс | 39,1 мс | +2% |
| PHP 8.3, JIT | 3,27 мс | 3,40 мс | +4% |
| Node.js 22 | 0,80 мс | 0,85 мс | +5% |
| PHP 8.3, без JIT | 10,79 мс | 12,47 мс | +16% |
| Bun 1.4 | 0,60 мс | 0,70 мс | +16% |
| Chromium 153 | 0,59 мс | 0,70 мс | +19% |
C, clang -O2 | 0,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. Если вы пишете под такую платформу, замеры выше говорят, что выигрыш реальный.
| |
§Итог
Обратный цикл был честной оптимизацией для эпохи, когда байткод исполнялся инструкция за инструкцией. На Nokia он давал 12%, и в интерпретаторе Java 21 до сих пор даёт 21–31%. Но в 2026 году почти любой код проходит через оптимизирующий компилятор, а компилятор лучше нас знает, как сравнивать счётчик и в каком порядке обходить память. В V8, JavaScriptCore, clang и HotSpot C2 обратный цикл работает медленнее обычного, иногда на треть.
Если хочется ускорить цикл, сначала стоит проверить другое: не вызывается ли в условии функция вроде count(), нет ли встроенной функции, которая делает то же самое (array_sum, sum), и правильно ли прогрет бенчмарк. А направление цикла лучше выбирать по смыслу задачи и писать так, как проще читать.
Исходный сниппет 2021 года: For loop optimizing. Инструкции байткода, о которых шла речь, описаны в спецификации JVM, глава 6.


