Летучие и синхронизированные

Question

Есть что-то, что я еще не понял о синхронизации и нестабильности.

Я понимаю, что поток может безопасно меняться локально. Из того, что я прочитал до сих пор, является синхронизированное> неустойчивое.

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

И у меня есть синхронизированный метод, когда я много работаю с этим Integer. Будут ли все потоки получать обновленную версию этого целого? Или я должен объявить его изменчивым?

public class stackoverflow { 

    private int x = 0; 

    public synchronized void rechnen(){ 
     //dosomething 
    } 
} 

в основном после rechnen() будет сделан, и я получил 10000 нитей, все будет получить версию обновления х, потому что мой метод синхронизации? или я должен объявить его изменчивым?

Answer 1

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

Answer 2

Синхронный метод уже установлен в вашем коде. Кроме того, Вы должны установить ваш х как летучие, как показано ниже

private volatile int x = 0; 

Это обеспечит поток, доступ к этому летучему полю, сначала прочитать текущее значение из основной памяти, вместо того, чтобы использовать потенциал процессор кэшированных значений

Таким образом, вы можете обеспечить ваш код потокобезопасно

Answer 3

Да, они получат обновленную версию, но только если они входят в синхронизированный блок самостоятельно. Если они не вводят синхронизированный блок на одном и том же объекте (блокировка одного и того же монитора), то не гарантируется, что они будут видеть обновления.

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

Answer 4

Объявить приватную переменную int x = 0; это будет служить вашей цели. Для лучшего понимания см. Реализацию AtomicInteger.

Answer 5

@partlov уже ответил на ваш вопрос, так как сторона примечания есть некоторые другие вещи, которые вы, возможно, захотите рассмотреть.

Не используйте синхронизируются в качестве модификатора

при объявлении метода, как синхронизируются он использует монитор. В Java каждый Object оказывается монитором, и в этом случае используется экземпляр класса. Таким образом, ваш пример аффективно становится следующим:

public void rechnen(){ 
    synchronized(this) { 
     //dosomething 
    } 
} 

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

Итак, главный совет: всегда держать свои мониторы в тайне.Так что-то вроде:

public class stackoverflow { 
    private final Object monitor = new Object(); 
    private int x = 0; 

    public void rechnen(){ 
     synchronized(monitor) { 
      //dosomething 
     } 
    } 
} 

знать ваше Api

Между volatile и synchronized есть множество инструментов для конкретных целей параллелизма. Большинство из них используют смесь volatile, synchronized и CAS-operations. Например, AtomicInteger дает вам операцию с целым числом атомов с гораздо меньшим количеством конфликтов, как это обычно видно из synchronized. Попробуйте войти по-настоящему знакомы с java.util.concurrent