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

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

, Таким образом, можно уменьшить вопрос глобальным переменным по сравнению с энергозависимыми переменными.

Теперь на энергозависимый:

Как const, volatile модификатор типа.

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

Объекты, объявленные как volatile, не могут использоваться в определенной оптимизации.

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

у доктора Jobb есть большая статья об энергозависимом .

Вот пример от статьи доктора Jobb:

class Gadget
{
public:
    void Wait()
    {
        while (!flag_)
        {
            Sleep(1000); // sleeps for 1000 milliseconds
        }
    }
    void Wakeup()
    {
        flag_ = true;
    }
    ...
private:
    bool flag_;
};

, Если компилятор видит, что Sleep() внешний вызов, он предположит, что Sleep() не может возможно изменить переменное значение _ флага. Таким образом, компилятор может сохранить значение flag_ в регистре. И в этом случае, это никогда не будет изменяться. Но если другое пробуждение вызовов потока, первый поток все еще читает из регистра ЦП. Wait() никогда не будет пробуждение.

Итак, почему не только никогда переменные кэша в регистры и не избегают проблемы полностью? Оказывается, что эта оптимизация может действительно сохранить Вас много времени в целом. Таким образом, C/C++ позволяет Вам явно отключать его через volatile ключевое слово.

факт выше того flag_ был членской переменной, и не глобальной переменной (ни статичный глобальный) не имеет значения. Объяснение после примера дает корректное обоснование, даже если Вы имеете дело с глобальными переменными (и статическими глобальными переменными).

распространенное заблуждение А - то, что объявление переменной volatile достаточно для обеспечения потокобезопасности. Операции на переменной все еще не являются атомарными, даже при том, что они не "кэшируются" в регистрах

энергозависимый с указателями:

Энергозависимый с указателями, работами как константа с указателями.

переменная А типа volatile int * означает, что переменная, на которую указывает указатель, энергозависима.

переменная А типа int * volatile означает, что сам указатель энергозависим.

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

Пример:

#define MYPORT 0xDEADB33F

volatile char *portptr = (char*)MYPORT;
*portptr = 'A';
*portptr = 'B';

Без "энергозависимого", первая запись может быть оптимизирована.

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

Энергозависимая переменная на Википедию

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

• Различные аппаратные средства (больше процессоров, различной архитектуры памяти)
• А новая версия компилятора с лучшей оптимизацией.
• Случайное изменение в синхронизации между потоками. Проблема может только произойти одно время в 10 миллионах.
• Различные настройки компиляторной оптимизации.

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

, Конечно, если Ваша программа не является многопоточной тогда, она не имеет значения.

Я ответ +1 Фриоля. Я хотел бы добавить некоторую точность, поскольку, кажется, существует много беспорядков в различных ответах: энергозависимый C не является энергозависимым Java.

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

Энергозависимый в C не имеет никакого отношения к аппаратным кэшам или многопоточности. Это не вставляет заборы памяти, и у Вас нет абсолютно никакого garanty на порядке операций, если два потока делают доступы к нему. Энергозависимое ключевое слово Java делает точно что хотя: вставка заборов памяти при необходимости.