В чем разница в использовании volatile keyword в java4 и java5 и далее?с использованием volatile ключевого слова в java4 и java5
и связанный с этим,
операции чтения/запись на неатомарном переменных (длинном/двойной) является атомарным, когда они объявлен как летучие.
Это также верно для java4 или он действует с Java5 года ???
Люди предоставили хорошие баллы и рекомендации, отвечая на мой вопрос, отвечая на первую часть.
Going специфичны для второй части вопроса, это я прочитал на каком-то форуме:
Летучие заявил долго атомное (предварительно Java 5 также) в том смысле, что это гарантирует (для всех JVM реализации) чтение или запись направляются непосредственно в основную память вместо двух 32-разрядных регистров.
И
Pre-Java 5, летучий был должен предоставить такие гарантии на длительный и двойной. Однако на практике все сложилось не так, и реализации часто нарушали эту гарантию. Насколько я помню, проблема , похоже, была исправлена вокруг JDK 1.4, но, поскольку они все еще находились , работая над всей моделью памяти, они действительно не делали никаких анонсов об этом до JDK 5, когда новые правила были объявили, а гарантии памяти на самом деле означали что-то.
И это от спецификации языка Java, Second Edition:
17,4 неатомического Лечение двойных и долго
нагрузки, магазин, читать и писать действия на летучем переменных atomic, , даже если тип переменной двойной или длинной.
Этот сайт дает хорошее объяснение различий: http://www.javamex.com/tutorials/synchronization_volatile.shtml
Они также дают объяснение поведения летучих в Java 5 на отдельной странице: http://www.javamex.com/tutorials/synchronization_volatile_java_5.shtml
Говорит первая справочная статья: «Начиная с Java 5 доступ к изменчивой переменной создает барьер памяти: он эффективно синхронизирует все кэшированные копии переменных с основной памятью» – Raedwald
Да есть разница.
До Java 4 volatile может быть переупорядочено компилятором в отношении любого предыдущего чтения или записи, что приводит к тонким ошибкам параллелизма, например. что делает невозможным внедрение блокировки double check (очень распространенная идиома для Singleton).
Это исправлено в Java 5.0, которое расширяет семантику для volatile, которая не может быть переупорядочена по отношению к любому следующему чтению или записи и вводит новую модель памяти. Вы можете прочитать это Double Checked Locking, например, ссылку
В чем разница в использовании ключевого слова volatile в java4 и java5 и далее?
JMM до того, как JDK5 сломан, и использование volatile для JDK4 может не дать ожидаемого результата. Для более проверить это: http://www.ibm.com/developerworks/library/j-jtp02244/
операции чтения/записи на неатомарных переменных (длинный/двойной) атомарные, когда они объявлены как изменчивы.
Чтение/запись для длинных/двойных событий происходит как две отдельные 32-битные операции. Для двух потоков возможно, что один поток считывает более высокие 32-битные, а другой имеет более низкие 32 бита длинной/двойной переменной. Короче говоря, чтение/запись по длине - это не атомная операция, в отличие от других примитивов. Использование volatile для long/double должно обеспечивать такую гарантию, поскольку инструкции для volatile не переупорядочены для изменчивого чтения/записи компилятором, а volatile также обеспечивает гарантию видимости. Но снова это может не работать для JDK 4 или раньше.
http://www.cs.umd.edu/~pugh/java/memoryModel/jsr-133-faq.html#volatile – Luciano
Почему вы предполагаете, что существуют какие-либо различия между java4 и java5, связанными с ключевым словом volatile? – claesv
@claesv потому что есть. Модель памяти Java изменилась между этими версиями. – Luciano