Следует использовать пример кода, который может доказать изменчивое объявление.

Вот пример того, почему volatile необходимо. Если вы удалите ключевое слово volatile, поток 1 может никогда не завершиться. (Когда я тестировал Java 1.6 Hotspot в Linux, это действительно было так — ваши результаты могут отличаться, поскольку JVM не обязана кэшировать переменные, не отмеченные volatile.)

public class ThreadTest {
  volatile boolean running = true;

  public void test() {
    new Thread(new Runnable() {
      public void run() {
        int counter = 0;
        while (running) {
          counter++;
        }
        System.out.println("Thread 1 finished. Counted up to " + counter);
      }
    }).start();
    new Thread(new Runnable() {
      public void run() {
        // Sleep for a bit so that thread 1 has a chance to start
        try {
          Thread.sleep(100);
        } catch (InterruptedException ignored) { 
         // catch block
        }
        System.out.println("Thread 2 finishing");
        running = false;
      }
    }).start();
  }

  public static void main(String[] args) {
    new ThreadTest().test();
  }
}

Ниже приведен канонический пример необходимости volatile (в данном случае для переменной str. Без нее точка доступа поднимает доступ за пределы цикла (while (str == null)) и run() никогда не завершается. Это произойдет на большинстве серверных JVM.

public class DelayWrite implements Runnable {
  private String str;
  void setStr(String str) {this.str = str;}

  public void run() {
    while (str == null);
    System.out.println(str);
  }

  public static void main(String[] args) {
    DelayWrite delay = new DelayWrite();
    new Thread(delay).start();
    Thread.sleep(1000);
    delay.setStr("Hello world!!");
  }
}

Эрик, я читал ваши комментарии, и один из них меня особенно поражает.

На самом деле, я могу понять использование volatile на концептуальном уровне. Но для практики я не могу придумать код с проблемами параллелизма без использования volatile

Очевидная проблема, с которой вы можете столкнуться, - это переупорядочение компилятора, например, более известный подъем, упомянутый Саймоном Никерсоном. Но допустим, что перестановок не будет, что комментарий может быть действительным.

Другая проблема, которую решает volatile, связана с 64-битными переменными (long, double). Если вы записываете в long или double, они рассматриваются как два отдельных 32-битных хранилища. Что может произойти с параллельной записью, так это то, что старшие 32 одного потока записываются в старшие 32 бита регистра, в то время как другой поток записывает младшие 32 бита. Можно потом иметь лонг что ни то ни другое.

Кроме того, если вы посмотрите на раздел памяти JLS, вы обнаружите, что это нестрогая модель памяти.

Это означает, что запись может не стать видимой (может находиться в буфере хранилища) какое-то время. Это может привести к устаревшим чтениям. Теперь вы можете сказать, что это кажется маловероятным, и это так, но ваша программа неверна и может дать сбой.

Если у вас есть int, который вы увеличиваете на время жизни приложения, и вы знаете (или, по крайней мере, думаете), что int не будет переполняться, вы не обновляете его до long, но все же возможно, что это возможно. В случае проблемы с видимостью памяти, если вы считаете, что это не должно повлиять на вас, вы должны знать, что это все еще может и может вызвать ошибки в вашем параллельном приложении, которые чрезвычайно трудно идентифицировать. Правильность является причиной использования volatile.

Ключевое слово volatile довольно сложное, и вам нужно понять, что оно делает, а что нет, прежде чем использовать его. Я рекомендую прочитать этот раздел спецификации языка, в котором объясняется это очень хорошо.

Они выделяют этот пример:

class Test {
    static volatile int i = 0, j = 0;
    static void one() { i++; j++; }
    static void two() {
        System.out.println("i=" + i + " j=" + j);
    }
}

Это означает, что в течение one() j никогда не превышает i. Однако другой поток, выполняющий two(), может вывести значение j, которое намного больше, чем i, поскольку, скажем, two() выполняется и получает значение i. Затем one() выполняется 1000 раз. Затем поток, выполняющий два, наконец, снова назначается и получает j, который теперь намного больше, чем значение i. Я думаю, что этот пример прекрасно демонстрирует разницу между volatile и синхронизированным — обновления i и j являются volatile, что означает, что порядок, в котором они происходят, соответствует исходному коду. Однако два обновления происходят отдельно, а не атомарно, поэтому вызывающие могут видеть значения, которые выглядят (для этого вызывающего) несовместимыми.

В двух словах: будьте очень осторожны с volatile!

Минималистский пример в Java 8, если вы удалите ключевое слово volatile, он никогда не закончится.

public class VolatileExample {

    private static volatile boolean BOOL = true;

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> { while (BOOL) { } }).start();
        TimeUnit.MILLISECONDS.sleep(500);
        BOOL = false;
    }
}

Чтобы расширить ответ @jed-wesley-smith, если вы добавите это в новый проект, удалите ключевое слово volatile из iterationCount и запустите его, он никогда не остановится. Добавление ключевого слова volatile к str или iterationCount приведет к успешному завершению кода. Я также заметил, что сон не может быть меньше 5 при использовании Java 8, но, возможно, ваш пробег может отличаться от других версий JVM/Java.

public static class DelayWrite implements Runnable
{
    private String str;
    public volatile int iterationCount = 0;

    void setStr(String str)
    {
        this.str = str;
    }

    public void run()
    {
        while (str == null)
        {
            iterationCount++;
        }
        System.out.println(str + " after " + iterationCount + " iterations.");
    }
}

public static void main(String[] args) throws InterruptedException
{
    System.out.println("This should print 'Hello world!' and exit if str or iterationCount is volatile.");
    DelayWrite delay = new DelayWrite();
    new Thread(delay).start();
    Thread.sleep(5);
    System.out.println("Thread sleep gave the thread " + delay.iterationCount + " iterations.");
    delay.setStr("Hello world!!");
}