Использование AtomicBoolean вместо синхронизированных блоков

Question

Скажем, у меня есть класс с 2-х переменных экземпляра и следующих методов (упрощенных по этому вопросу):

private final Object lock = new Object(); 
private boolean running; 

public MyClass() { 
    synchronized(lock) { 
     running = false; 
    } 
} 
public void methodA() { 
    synchronized(lock) { 
     running = true; 
    } 
} 
public void methodB() { 
    synchronized(lock) { 
     if (!running) { 
      return; 
     } 
    } 
} 

Я смотрел на этот код, и после прочтения о AtomicBoolean я подумал, что здесь можно поместиться, особенно после просмотра конструктора MyClass и methodA. Однако я не был уверен в том, что methodB.

Если предположить, что эти методы могут вызываться несколькими потоками, будет следующее поточно-?:

private AtomicBoolean running; 

public MyClass() { 
    running = new AtomicBoolean(false); 
} 
public void methodA() { 
    running.set(true); 
} 
public void methodB() { 
    if (!running.get()) { 
     return; 
    } 
} 

Будет running.get() быть гарантировано, чтобы увидеть обновление через running.set(true) или running.set(false) из другого потока?

Answer 1

В вашем примере достаточно простого volatile boolean, так как вы только делаете атомарные операции. AtomicBoolean полезна, если вам нужны такие методы, как compareAndSet.

Так что, отвечая на ваш вопрос, да, при использовании volatile boolean или AtomicBoolean, другие потоки будут видеть обновления переменной.

Answer 2

Да. От Javadoc от AtomicBoolean:

Значение {@code boolean}, которое может быть обновлено атомарно.

Это означает, что любое обновление AtomicBoolean является неделимой. Поэтому я бы счел такое использование AtomicBooleanпотоковым сейфом.

Вы должны еще рассмотреть возможность сделать заявление о AtomicBoolean окончательных:

private final AtomicBoolean running;

Answer 3

Вообще эти блоки коды не равны для methodB, потому что чтение volatile переменных не создает порядок синхронизации.

Представьте, что вы имеете некоторое другое поле int x = 42 в своем классе, который обновляется в methodB:

public void methodB() { 
    if (!running.get()) { 
     return; 
    } 
    if (x < 50) x++; // just example 
} 

Тогда у вас есть несколько потоков, которые называют methodB:

• при использовании синхронизированного ключевого слова, обновление безопасный и видимый для всех потоков.
• при использовании AtomicBoolean/летучей видимости нарушается

Если нет такого случая с переменным обновлением и задача только обеспечить видимость между Methoda - последовательностью methodB, то это нормально - AtomicBoolean достаточно для этого.