вопрос о «Java Concurrency in Practice» пример

Question

Я ищу образец кода из «Java Concurrency in Practice» Брайана Гетца. Он говорит, что возможно, что этот код останется в бесконечном цикле, потому что «значение« готово »никогда не станет видимым для потока читателя». Я не понимаю, как это может произойти ...

public class NoVisibility { 
    private static boolean ready; 
    private static int number; 

    private static class ReaderThread extends Thread { 
     public void run() { 
      while (!ready) 
       Thread.yield(); 
      System.out.println(number); 
     } 
    } 

    public static void main(String[] args) { 
     new ReaderThread().start(); 
     number = 42; 
     ready = true; 
    } 
} 

Answer 1

Поскольку ready не помечено как volatile и значение может быть кэшируются в начале цикла while, потому что она не изменяется в течение цикла while , Это один из способов оптимизации кода дрожания.

Так что возможно, что поток начинается до ready = true и читает ready = false, который кэширует этот поток локально и никогда не читает его снова.

Отъезд the volatile keyword.

Answer 2

Причина объясняется в разделе, следующем за примером с образцом кода.

3.1.1 Устаревшие данные

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

Answer 3

Модель памяти Java позволяет JVM оптимизировать ссылки доступ и такие, как если бы это однопоточное приложение, если поле не помечено как volatile или доступы с замком проводятся (история становится немного сложнее с блокировками на самом деле).

В примере, вы предоставили, виртуальная машина может сделать вывод, что ready поле не может быть изменен в течение текущего потока, поэтому было бы заменить !ready с false, вызывая бесконечный цикл. Маркировка поля как volatile заставит JVM каждый раз проверять значение поля (или, по крайней мере, обеспечивать, чтобы изменения ready распространялись на текущий поток).

Answer 4

private static boolean ready; 
private static int number; 

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

Jeremy Manson and Brian Goetz:

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

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

Answer 5

Проблема связана с аппаратным обеспечением - каждый процессор имеет другое поведение в отношении когерентности кэш-памяти, видимости памяти и переупорядочения операций. Java здесь лучше, чем C++, потому что он определяет кросс-платформенную модель памяти, на которую могут рассчитывать все программисты. Когда Java работает в системе, модель памяти которой слабее той, которая требуется для модели памяти Java, JVM должна внести свой вклад.

Языки, подобные C "наследуют" модель памяти базового оборудования. Есть работа, чтобы дать C++ формальную модель памяти, чтобы программы на C++ могли означать одно и то же на разных платформах.

Answer 6

public class NoVisibility { 

    private static boolean ready = false; 
    private static int number; 

    private static class ReaderThread extends Thread { 

     @Override 
     public void run() { 
      while (!ready) { 
       Thread.yield(); 
      } 
      System.out.println(number); 
     } 
    } 

    public static void main(String[] args) throws InterruptedException { 
     new ReaderThread().start(); 
     number = 42; 
     Thread.sleep(20000); 
     ready = true; 
    } 
} 

Поместите Thread.sleep() вызов в течение 20 секунд, что будет происходить в JIT начнется в течение этих 20 секунд, и он будет оптимизировать проверку и кэшировать значение или удалить состояние в целом. И поэтому код не будет отображаться.

Чтобы прекратить это, вы ДОЛЖНЫ использовать volatile.