Энергозависимые гарантии и выполнение с изменением последовательности [дубликат]

Этот вопрос уже имеет ответ здесь:

• Модель памяти Java: энергозависимые переменные и происходят - перед 3 ответами

ВАЖНОЕ РЕДАКТИРОВАНИЕ, которое я знаю о, "происходит, прежде" в потоке, где эти два присвоения происходят, мой вопрос, был бы это быть возможным для другого потока считать "b" непустой указатель, в то время как "a" является все еще пустым. Таким образом, я знаю, что при вызове мелкой монеты () от того же потока как тот, где Вы ранее назвали setBothNonNull (...) затем, он не может бросить NullPointerException. Но что, если Вы называете мелкую монету () от другого потока, чем тот, звоня setBothNonNull (...)?

Обратите внимание, что этот вопрос только о volatile ключевое слово и volatile гарантии: это не о synchronized ключевое слово (поэтому не отвечайте, что "необходимо использовать, синхронизируются", поскольку у меня нет проблемы для решения: Я просто хочу понять volatile гарантии (или отсутствие гарантий) относительно выполнения с изменением последовательности).

Скажите, что у нас есть объект, содержащий два volatile Строковые ссылки, которые инициализируются к пустому указателю конструктором и что у нас есть только один способ изменить эти две Строки: путем вызова setBoth (...) и что мы можем только установить их ссылки впоследствии на ненулевую ссылку (только конструктору разрешают установить их в NULL).

Например (это - просто пример, еще нет никакого вопроса):

public class SO {

    private volatile String a;
    private volatile String b;

    public SO() {
        a = null;
        b = null;
    }

    public void setBothNonNull( @NotNull final String one, @NotNull final String two ) {
        a = one;
        b = two;
    }

    public String getA() {
        return a;
    }

    public String getB() {
        return b;
    }

}

В setBothNoNull (...), строка, присваивающая непустой параметр "a", появляется перед строкой, присваивающей непустой параметр "b".

Затем, если я делаю это (еще раз, нет никакого вопроса, вопрос прибывает затем):

doIt() {
    if ( so.getB() != null ) {
        System.out.println( so.getA().length );
    }
}

Я корректен в своем понимании, что из-за выполнения с изменением последовательности я могу получить NullPointerException?

Другими словами: нет никакой гарантии, что, потому что я считал непустой указатель "b", я считаю непустой указатель "a"?

Поскольку из-за неисправного (много) процессора и пути volatile работы "b" могли быть поручены прежде "a"?

volatile гарантии, который читает последующий за записью, должны всегда видеть последнее записанное значение, но здесь существует неисправное право "проблемы"? (еще раз "проблема" сделана нарочно попытаться понять семантику volatile ключевое слово и Модель памяти Java, для не решения проблемы).