Летучие семантический относительно других полей

Question

Предположим, что у меня есть следующий код

private volatile Service service; 

public void setService(Service service) { 
    this.service = service; 
} 

public void doWork() { 
    service.doWork(); 
} 

Modified поле помечено как изменчивы и его значение не зависит от предыдущего состояния. Итак, это правильный многопоточный код (не беспокойтесь о Service реализациях за минуту).

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

Означает ли это, что следующий код верен?

private volatile boolean serviceReady = false; 
private Service service; 

public void setService(Service service) { 
    this.service = service; 
    this.serviceReady = true; 
} 

public void doWork() { 
    if (serviceReady) { 
    service.doWork(); 
    } 
} 

Answer 1

Да, этот код является «правильным» в его нынешнем виде, начиная с Java 1.5.

Атомность не является проблемой, с или без энергозависимой (записи на ссылки на объекты являются атомарными), поэтому вы можете пересечь это из списка проблем в любом случае - единственный открытый вопрос - видимость изменений и «правильность», заказа.

Любая запись в изменчивую переменную устанавливает связь «произошла до» (ключевая концепция новой модели памяти Java, как указано в JSR-133) с любыми последующими чтениями одной и той же переменной. Это означает, что поток чтения должен иметь видимость во всем видимом для записывающего потока: то есть он должен видеть все переменные с не менее их «текущими» значениями во время записи.

Мы можем объяснить это в деталях, глядя на section 17.4.5 of the Java Language Specification, в частности, следующие ключевые моменты:

1. «Если х и у являются действия одного и того же нити и х предшествует у в программном порядке, то ро (x, y) "(т. е. действия одного и того же потока не могут быть переупорядочены таким образом, чтобы они не соответствовали порядку программирования)
2. « Запись в изменчивое поле (§8.3.1.4) происходит до каждого последующего чтения это поле ". (это поясняющий текст, объясняющий, что чтение-считывание летучего поля является точкой синхронизации)
3. «Если hb (x, y) и hb (y, z), то hb (x, z)» (транзитивность происходит, перед тем)

Таким образом, в вашем примере:

• записываемый в «сервис» (а) происходит, перед записью в «serviceReady» (б), в связи с правилом 1
• запись в сервисный режим (b) происходит до того, как она считывается с тем же (c), из-за правила 2
• поэтому, (a) происходит-до (c) (3-е правило)

означает, что вам гарантировано, что «сервис» установлен правильно, в этом случае, как только serviceReady является истинным.

Вы можете увидеть некоторые хорошие записи окна используя почти точно тот же самый пример, один на IBM DeveloperWorks - см «Новые гарантии для Летучего»:

значения

, которые были видны А в то время, V была написана гарантированно теперь будет видна B.

и один в the JSR-133 FAQ, написанной авторами этой JSR:

Таким образом, если читатель видит значение true для v, также гарантировано, что запись будет записана до 42. Это не было бы правдой при старой модели памяти. Если v не были волатильными, то компилятор мог изменить порядок записи в записи, а чтение читателем x могло бы увидеть 0.

Answer 2

Вы правы о влиянии volatile, так что это должно быть правильным, но я запутался о вашем дизайне. Я не понимаю, почему вы не просто синхронизируете setService - это, вероятно, не будет вызываться часто. Если это называется более чем один раз, «if (serviceReady)» часть является спорной, так как он все равно будет верно, но это нормально, так как замена атомарная, если я правильно понимаю.

Полагаю, что service.doWork() является потокобезопасным, да?

Answer 3

AFAIK это правильный код.

@CPerkins: только синхронизируемый метод setService не будет работать, так как вам также нужно синхронизировать при чтении.

Однако одной переменной было бы достаточно в этом случае. Зачем вам нужно дополнительное логическое поле. .

private volatile Service service; 

public void setService(Service service) { 
    this.service = service; 
} 

public void doWork() { 
    if (service != null) { 
    service.doWork(); 
    } 
} 

при условии, что никто никогда не называет setService к null. Поэтому вам следует, вероятно, проверить нуль:

private volatile Service service; 

public void setService(Service service) { 
    if (service == null) throw NullPointerException(); 
    this.service = service; 
} 

public void doWork() { 
    if (service != null) { 
    service.doWork(); 
    } 
} 

Answer 4

Теоретически он никогда не должен работать. Вы хотите обеспечить согласованность памяти для двух переменных, и вы хотите полагаться на volatile read на первый. Волатильное чтение только гарантирует, что поток чтения видит последнее значение переменной. Так что это определенно не так сильно, как вход в заблокированную (синхронизированную) секцию.

На практике это может сработать, в зависимости от реализации изменчивости используемой вами JVM. Если волатильные чтения выполняются путем сброса всех кэшей ЦП, он должен работать. Но я готов поспорить, что этого не произойдет. Can I force cache coherency on a multicore x86 CPU? хорошо читал эту тему.

Я бы сказал, что для этих двух переменных просто существует общий замок (java.util.concurrent.Lock или синхронизирован) и выполняться с ним.

---

Java Language Specification, Third Edition, это сказать о летучем:

8.3.1.4 Летучих Поля

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

и

17.4.4 Порядок синхронизации

• Запись в летучем переменной (§8.3.1.4) v-синхронизирует со всеми последующее чтение V любым потоком (где затем определяется в соответствии с порядком синхронизации).
• Запись в изменчивое поле (§8.3.1.4) происходит до каждого последующего чтения этого поля.

В нем ничего не говорится о влиянии видимости других переменных.