Вопрос в стиле головоломок с offline-конференций: Что выведет этот код при запуске?

import java.util.concurrent.atomic.AtomicInteger;

public class Disturbed {

    public static void main(String... args) {
        AtomicInteger counter = new AtomicInteger(1);
        System.out.println(
            "First two positive numbers: " +
            counter + 
            ", " +
            counter.incrementAndGet()
        );
    }

}

Помедитируйте немного над кодом и приходите за ответом под кат.

Вероятно, что увидев код многие воскликнули «Это же элементарно, Ватсон!»
Ответом, однако, будет фраза «Зависит от компилятора и параметров компиляции».

Код, скомпилированный JDK 8 и более ранними выдаст ожидаемое:

First two positive numbers: 1, 2

Однако при компиляции в JDK 9 и более новых мы внезапно получим ответ:

First two positive numbers: 2, 2

Всё изложенное в данной заметке проверялось на компиляторах из Oracle JDK/OpenJDK, в других реализациях могут быть другие баги.

Предпосылки

Среди нововведений Java 9 был JEP 280, новый механизм конкатенации строк.

Конкатена́ция (лат. concatenatio «присоединение цепями; сцепле́ние») — операция склеивания объектов линейной структуры, обычно строк. Например, конкатенация слов «микро» и «мир» даст слово «микромир».

Конкатенация — Википедия

Целью было сделать возможной оптимизацию конкатенации строк без необходимости перекомпиляции программ из исходников. Обновил JDK — увеличил производительность. Магия!

Традиционно, с самого начала времён, конкатенация строк транслировалась компилятором в создание экземпляра класса StringBuilder, серию вызовов StringBuilder::append() и преобразование результата в строку при помощи вызова StringBuilder::toString() в финале.

Так, например, конструкция System.out.println("Hello, " + name + "!"); превращалась в

System.out.println(
  (new StringBuilder())
  .append("Hello, ")
  .append(name)
  .append("!")
  .toString()
);

При новом подходе все манипуляции с StringBuilder исчезают и заменяются одной инструкцией invokedynamic. В качестве bootstrap-метода при этом используется один из методов класса java.lang.invoke.StringConcatFactory.

Чистой Java это не передать, но javap -c -v покажет нам примерно такой байткод:

   0: getstatic     #23                 // Field java/lang/System.out:Ljava/io/PrintStream;
   3: aload_0
   4: invokedynamic #27,  0             // InvokeDynamic #0:makeConcatWithConstants:(Ljava/lang/String;)Ljava/lang/String;
   9: invokevirtual #31                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V

...

LocalVariableTable:
  Start  Length  Slot  Name   Signature
      0      13     0  name   Ljava/lang/String;

...

BootstrapMethods:
  0: #50 REF_invokeStatic java/lang/invoke/StringConcatFactory.makeConcatWithConstants:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/invoke/CallSite;
    Method arguments:
      #56 Hello, \u0001!

В чём проблема?

Само собой, предполагалось, что изменение никак не повлияет на поведение пользовательского кода. Но не всегда и не всё можно предусмотреть. Java 9 была выпущена в 2017 году, а в сентябре этого года был зарегистрирован баг JDK-8273914.

Как обнаружилось, javac генерирует байткод, нарушающий JLS, пункт §15.7.1. Последний требует для бинарных операций чтобы левая часть выражения была полностью вычислена перед тем, как будет вычислена правая:

15.7.1. Evaluate Left-Hand Operand First

The left-hand operand of a binary operator appears to be fully evaluated before any part of the right-hand operand is evaluated.

Это требование без всяких ухищрений выполняется при использовании старого-доброго StringBuilder, но не всегда выполняется при использовании новой стратегии.

Сравним поведение на примере выражения из Кода Для Привлечения Внимания, предварявшего эту статью:

StringBuilder

    // Создаём буфер для формирования результата конкатенации.
    (new StringBuilder())
    // Добавляем к результату строку "First two positive numbers: "
    .append("First two positive numbers: ")
    // Разыменовываем ссылку на объект counter и переводим его в
    // строковое представление, неявно вызывая метод toString()
    .append(counter)
    // Добавляем к результату строку ", "
    .append(", ")
    // Увеличиваем значение счётчика на единицу и получаем новое значение как
    // целое число. Полученное число переводим в строковое предствление 
    // и добавляем к результату.
    .append(counter.incrementAndGet())
    // Получаем содержимое буфера в виде строки.
    .toString()

JEP 280

Это ассемблер, но не пугайтесь, дальше будет псевдокод.

    // Помещаем ссылку на экземпляр счётчика на стек.
    // Сейчас его внутреннее состояние хранит значение равное единице,
    // но это ничего не значит.
    aload_1;
    // Разыменовываем ссылку на экземпляр счётчика и вызываем его метод incrementAndGet()
    // Состояние счётчика меняется с 1 на 2, новое значение в виде целого числа 
    // типа int возвращается в качестве результата вызова и помещается на вершину
    // стека.
    aload_1;
    invokevirtual   Method java/util/concurrent/atomic/AtomicInteger.incrementAndGet:"()I";
    // Ссылка на экземпляр счётчика и его последнее значение приходят в качестве
    // параметров в метод, реализующий конкатенацию. Там они будут переведены в
    // строковое представление и подставлены в строку-шаблон.
    invokedynamic   
        InvokeDynamic REF_invokeStatic
        :Method java/lang/invoke/StringConcatFactory.makeConcatWithConstants
        :"(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/invoke/CallSite;":makeConcatWithConstants
        :"(Ljava/util/concurrent/atomic/AtomicInteger;I)Ljava/lang/String;" 
    {
      // Строка-шаблон. Символами \u0001 обозначаются места, в которые будут
      // подставлены значения из параметров.
      String "First two positive numbers: \u0001, \u0001"
    };

Процитированный выше фрагмент можно представить в виде такого псевдокода:

    // Помещаем ссылку на экземпляр счётчика на стек.
    // Сейчас его внутреннее состояние хранит значение равное единице,
    // но это ничего не значит.
    AtomicInteger temp1 = counter;
    // Разыменовываем ссылку на экземпляр счётчика и вызываем его метод incrementAndGet()
    // Состояние счётчика меняется с 1 на 2, новое значение в виде целого числа 
    // типа int возвращается в качестве результата вызова и помещается на вершину
    // стека.
    int temp2 = counter.incrementAndGet();
    // Ссылка на экземпляр счётчика и его последнее значение приходят в качестве
    // параметров в метод, реализующий конкатенацию. Там они будут переведены в
    // строковое представление и подставлены в строку-шаблон.
    String result = makeConcatWithConstants(
        "First two positive numbers: \u0001, \u0001",
        temp1,
        temp2
    );

    ...

    System.out.println(result);

Другими словами, в метод makeConcatWithConstants() объект count придёт уже в изменённом состоянии и результат будет неверным. Мистерия раскрыта!

Добиться стабильной работы нашего КДПВ можно просто заменив в выражении counter на counter.get(), а в более общем случае — явно приведя к строковому представлению все значения ссылочных типов, встречающиеся в выражении.

Если этот баг вызывает у вас серьёзное беспокойство, то вы можете временно откатиться на использование старого способа конкатенации строк.

Для это нужно при компиляции передать javac параметр -XDstringConcat=inline:

javac -XDstringConcat=inline Disturbed.java

Мораль

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