Использование энергозависимого спецификатора в C/C ++/Java

Технически ваш вопрос известен как «банка с червями»! Для c / c ++ (я не могу комментировать java)
Вы можете очень грубо охарактеризовать volatile как указание компилятору сказать «пожалуйста, не оптимизируйте это», но среди профессионалов есть много споров относительно того,
a) Все полезно для кода уровня ядра <-Edit разъяснено на основе отзывов
б) Даже правильно реализовано большинством компиляторов.

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

= Edit = Интересно, чего стоит. Деннис Ричи был против его включения (а также const) подробностей здесь

Здесь есть хорошее объяснение : http://en.wikipedia.org/wiki/Volatile_variable , но немного упрощенный, он сообщает компилятору, что он не должен предполагать, что к переменной не обращается кто-то еще и что ее оптимизация фатальна в регистратор и обновлять только реестр, а не фактическое хранилище.

Я нашел эту статью DDJ Херба Саттера очень интересной, особенно то, как volatile обрабатывается в C ++, Java и C # .NET.

Dr.Dobbs volatile vs. volatile

Изменчивые переменные полезны в Java (по крайней мере, начиная с Java 5.0, где их поведение изменилось ), как говорит Брайан Гетц в своей книге «Java Concurrency in Practice» (JCIP) - основная книга по этому вопросу (стр. 37):

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

Explicit synchronization can also achieve this, but often we do not always want to lock a value. Double Checked locking is the classic example of this (copied from Wikipedia):

// Works with acquire/release semantics for volatile
// Broken under Java 1.4 and earlier semantics for volatile
class Foo {
    private volatile Helper helper = null;
    public Helper getHelper() {
        if (helper == null) {
            synchronized(this) {
                if (null == helper)
                    helper = new Helper();
            }
        }
        return helper;
    }

    // other functions and members...
}

This would not work if the helper was not volatile.

Volatile variables can also be used to implement non-locking concurrent datastructures, such as java.util.concurrent.ConcurrentHashMap (which supports concurrent updates and access without locking - see the JDK source code for its use of volatiles).

JCIP has a nice discussion of double-checked locking, volatile variables, and Java concurrency in general. "Effective Java", 2nd Edition, by Joshua Bloch is also worth reading.

Also note that atomic variables are supported in Java in the java.util.concurrent.atomic package. These allow changes to values to be made visible across threads/processors in a similar way to volatile variables, but also allow "Compare And Set" operations to be performed, which means that some additional types of concurrent operations can safely be performed without locking.

Ключевое слово volatile давно появилось в C, и в основном оно «отключает» некоторые оптимизации компилятора, которые предполагают, что если переменная не была изменена явно, она не была изменена в все. Его основная полезность в те дни заключалась в объявлении переменных, которые будут изменены обработчиками прерываний. Я, например, однажды использовал его (конец 80-х) для глобальной переменной, содержащей позицию курсора мыши. Положение было изменено прерыванием, и без volatile основная программа иногда не обнаруживала его изменений, потому что компилятор оптимизировал доступ к переменной, полагая, что в этом нет необходимости.

Сегодня такое использование, как правило, устарело ( если вы не пишете низкоуровневый код ОС), но все же есть некоторые редкие ситуации, в которых volatile полезен (действительно, очень редко - я, например, вероятно, не использовал его последние 7 лет)

Но для многопоточного программирования это совершенно не рекомендуется. Проблема в том, что он не защищает одновременный доступ между потоками, а удаляет только оптимизацию, которая помешала бы его «обновлению» в том же потоке. Он не предназначен для использования в многопоточных средах. Если вы используете Java, используйте synchronized. Если вы работаете на C ++, используйте какую-нибудь библиотеку синхронизации, например pthreads или Boost.Threads (или, еще лучше, используйте новые библиотеки потоков C ++ 0X, если можете).

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

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

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

Я давно не занимался C ++, и я действительно не помню определения volatine на этом языке. Но в спецификации языка Java специально сказано, что цель volatile - облегчить многопоточный доступ к переменной. Цитата: «Поле может быть объявлено изменчивым, и в этом случае модель памяти Java (§17) гарантирует, что все потоки видят согласованное значение переменной». Далее они говорят, что ссылки на изменчивые значения гарантированно выполняются в том порядке, в котором они указаны в коде, т. Е. если вы объявите i и j volatile, а затем напишете "++ i; ++ j", тогда i, по сути, всегда будет увеличиваться до j.

Я помню, что единственный раз, когда я использовал volatile в Java, был, когда у меня один поток, возможно, устанавливает флаг отмены, а другой поток выполняет какую-то большую операцию и каждый раз в цикле проверяет флаг отмены. Это действительно сработало, как я ожидал.

Я согласен, что «volatile» имеет очень ограниченную полезность. Для большинства многопоточности в какой-то момент требуется "синхронизация". Но «ограничено» и «нет» - не одно и то же. Функция косинуса также имеет очень ограниченную полезность в большинстве бизнес-приложений. Но когда вам это нужно, вау, это избавит вас от многих проблем.

Единственный раз, когда я вспоминал об использовании volatile в Java, был случай, когда у меня был один поток, который, возможно, устанавливал флаг отмены, а другой поток выполнял какую-то большую операцию и каждый раз в цикле проверял флаг отмены. Это действительно сработало, как я ожидал.

Я согласен, что «volatile» имеет очень ограниченную полезность. Для большинства многопоточности в какой-то момент требуется "синхронизация". Но «ограничено» и «нет» - не одно и то же. Функция косинуса также имеет очень ограниченную полезность в большинстве бизнес-приложений. Но когда вам это нужно, вау, это избавит вас от многих проблем.

Единственный раз, когда я вспоминал об использовании volatile в Java, был случай, когда у меня был один поток, который, возможно, устанавливал флаг отмены, а другой поток выполнял какую-то большую операцию и каждый раз в цикле проверял флаг отмены. Это действительно сработало, как я ожидал.

Я согласен, что «volatile» имеет очень ограниченную полезность. Для большинства многопоточности в какой-то момент требуется "синхронизация". Но «ограничено» и «нет» - не одно и то же. Функция косинуса также имеет очень ограниченную полезность в большинстве бизнес-приложений. Но когда вам это нужно, вау, это избавит вас от многих проблем.

Я согласен, что «volatile» имеет очень ограниченную полезность. Для большинства многопоточности в какой-то момент требуется "синхронизация". Но «ограничено» и «нет» - не одно и то же. Функция косинуса также имеет очень ограниченную полезность в большинстве бизнес-приложений. Но когда вам это нужно, вау, это избавит вас от многих проблем.

Я согласен, что «volatile» имеет очень ограниченную полезность. Для большинства многопоточности в какой-то момент требуется "синхронизация". Но «ограничено» и «нет» - не одно и то же. Функция косинуса также имеет очень ограниченную полезность в большинстве бизнес-приложений. Но когда вам это нужно, вау, это избавит вас от многих проблем.