為什麼使用volatile ？

C/C++中的 volatile 關鍵字 和const對應，用來修飾變數，通常用於建立語言級別的memory barrier。這是BS在“The C++ Programming Language”對volatile修飾詞的解釋：
A volatile specifier is a hint to a compiler that an object may change its value in ways not specified by the language so that aggressive optimizations must be avoided.

volatile 關鍵字是一種型別修飾符，用它宣告的型別變量表示可以被某些編譯器未知的因素更改，比如：作業系統，硬體或者其他執行緒等。

遇到這個關鍵字宣告的變數，編譯器對訪問該變數的程式碼就不再進行優化，從而可以提供對特殊地址的穩定訪問。宣告時語法：int volatile vInt; 當要求使用 volatile 宣告的變數的值的時候，系統總是重新從它所在的記憶體讀取資料，即使它前面的指令剛剛從該處讀取過資料。而且讀取的資料立刻被儲存。例如：

volatile int i=10; 
int a = i; 
... 
// 其他程式碼，並未明確告訴編譯器，對 i 進行過操作 
int b = i; 
volatile int i=10;
int a = i;
...
// 其他程式碼，並未明確告訴編譯器，對 i 進行過操作
int b = i;

volatile 指出 i 是隨時可能發生變化的，每次使用它的時候必須從 i的地址中讀取，因而編譯器生成的彙編程式碼會重新從i的地址讀取資料放在 b 中。而優化做法是，由於編譯器發現兩次從 i讀資料的程式碼之間的程式碼沒有對 i 進行過操作，它會自動把上次讀的資料放在 b 中。而不是重新從 i 裡面讀。這樣以來，如果 i是一個暫存器變數或者表示一個埠資料就容易出錯，所以說 volatile 可以保證對特殊地址的穩定訪問。注意，在 VC 6 中，一般除錯模式沒有進行程式碼優化，所以這個關鍵字的作用看不出來。下面通過插入彙編程式碼，測試有無 volatile 關鍵字，對程式最終程式碼的影響：

輸入下面的程式碼：

#include <stdio.h> 
 
void main() 
{ 
 int i = 10; 
 int a = i; 
 
 printf("i = %d",a); 
 
 // 下面彙編語句的作用就是改變記憶體中 i 的值 
 // 但是又不讓編譯器知道 
 __asm{ 
 mov dword ptr [ebp-4],20h 
 } 
 
 int b = i; 
 printf("i = %d",b); 
} 
#include <stdio.h>
 
void main()
{
 int i = 10;
 int a = i;
 
 printf("i = %d",a);
 
 // 下面彙編語句的作用就是改變記憶體中 i 的值
 // 但是又不讓編譯器知道
 __asm{
 mov dword ptr [ebp-4],20h
 }
 
 int b = i;
 printf("i = %d",b);
}

然後，在 Debug 版本模式執行程式，輸出結果如下：

i = 10
i = 32
然後，在 Release 版本模式執行程式，輸出結果如下：

i = 10
i = 10
輸出的結果明顯表明，Release 模式下，編譯器對程式碼進行了優化，第二次沒有輸出正確的 i 值。下面，我們把 i 的宣告加上 volatile 關鍵字，看看有什麼變化：

#include <stdio.h> 
 void main() 
{ 
 volatile int i = 10; 
 int a = i; 
 printf("i = %d",a); 
 __asm { 
 mov dword ptr [ebp-4],b); 
} 
#include <stdio.h>
 
void main()
{
 volatile int i = 10;
 int a = i;
 
 printf("i = %d",a);
 __asm {
 mov dword ptr [ebp-4],b);
}

分別在 Debug 和 Release 版本執行程式，輸出都是：

i = 10
i = 32

這說明這個 volatile 關鍵字發揮了它的作用。其實不只是“內嵌彙編操縱棧”這種方式屬於編譯無法識別的變數改變，另外更多的可能是多執行緒併發訪問共享變數時，一個執行緒改變了變數的值，怎樣讓改變後的值對其它執行緒 visible。一般說來，volatile用在如下的幾個地方：
1) 中斷服務程式中修改的供其它程式檢測的變數需要加volatile；
2) 多工環境下各任務間共享的標誌應該加volatile；
3) 儲存器對映的硬體暫存器通常也要加volatile說明，因為每次對它的讀寫都可能由不同意義；

2.volatile 指標

和 const 修飾詞類似，const 有常量指標和指標常量的說法，volatile 也有相應的概念：

修飾由指標指向的物件、資料是 const 或 volatile 的：

const char* cpch; 
volatile char* vpch; 
const char* cpch;
volatile char* vpch;

注意：對於 VC，這個特性實現在 VC 8 之後才是安全的。指標自身的值——一個代表地址的整數變數，是 const 或 volatile 的：

char*const pchc; 
char*volatile pchv; 
char*const pchc;
char*volatile pchv;

注意：

(1) 可以把一個非volatile int賦給volatile int，但是不能把非volatile物件賦給一個volatile物件。

(2) 除了基本型別外，對使用者定義型別也可以用volatile型別進行修飾。
(3) C++中一個有volatile識別符號的類只能訪問它介面的子集，一個由類的實現者控制的子集。使用者只能用const_cast來獲得對型別介面的完全訪問。此外，volatile向const一樣會從類傳遞到它的成員。

3. 多執行緒下的volatile
有些變數是用volatile關鍵字宣告的。當兩個執行緒都要用到某一個變數且該變數的值會被改變時，應該用volatile宣告，該關鍵字的作用是防止優化編譯器把變數從記憶體裝入CPU暫存器中。如果變數被裝入暫存器，那麼兩個執行緒有可能一個使用記憶體中的變數，一個使用暫存器中的變數，這會造成程式的錯誤執行。volatile的意思是讓編譯器每次操作該變數時一定要從記憶體中真正取出，而不是使用已經存在暫存器中的值，如下：

volatile BOOL bStop = FALSE; 
// 在一個執行緒中： 
 while( !bStop ) { ... } 
bStop = FALSE; 
return; 
 
//在另外一個執行緒中，要終止上面的執行緒迴圈： 
bStop = TRUE; 
while( bStop ); //等待上面的執行緒終止， 
volatile BOOL bStop = FALSE; 
 
// 在一個執行緒中： 
 while( !bStop ) { ... } 
bStop = FALSE; 
return; 
 
//在另外一個執行緒中，要終止上面的執行緒迴圈： 
bStop = TRUE; 
while( bStop ); //等待上面的執行緒終止，

如果bStop不使用volatile申明，那麼這個迴圈將是一個死迴圈，因為bStop已經讀取到了暫存器中，暫存器中bStop的值永遠不會變成FALSE，加上volatile，程式在執行時，每次均從記憶體中讀出bStop的值，就不會死迴圈了。
這個關鍵字是用來設定某個物件的儲存位置在記憶體中，而不是暫存器中。因為一般的物件編譯器可能會將其的拷貝放在暫存器中用以加快指令的執行速度，例如下段程式碼中：

在此段程式碼中，nMyCounter的拷貝可能存放到某個暫存器中（迴圈中，對nMyCounter的測試及操作總是對此暫存器中的值進行），但是另外又有段程式碼執行了這樣的操作：nMyCounter -= 1;這個操作中，對nMyCounter的改變是對記憶體中的nMyCounter進行操作，於是出現了這樣一個現象：nMyCounter的改變不同步。

下面是volatile變數的幾個例子：

1.並行裝置的硬體暫存器（如：狀態暫存器

2.一箇中斷服務子程式中會訪問到的非自動變數(Non-automatic variables)

3.多執行緒應用中被幾個任務共享的變數

看下面例題:

int square(volatile int *ptr)
{
 return *ptr * *ptr;
}

這個程式有什麼問題嗎? 如果我們不去關心volatile關鍵字的話，那麼這個程式你怎麼看都會覺得沒多大問題.但是這裡

面問題大這ne， 首先引數宣告為volatile就是表明*ptr可能會隨時改變.上述程式碼執行時，編譯器可能產生這樣的程式碼:

int square(volatile int *ptr)
{
 int a,b;
 a = *ptr;
 b = *ptr;
 return a * b;
}

因為你的*ptr是隨時都可以意想不到的變化，所以有可能a*b的時候，a b的值不相同. 這樣你就得到一個錯誤的結果

改正後的程式:

int square(volatile int *ptr)
{
 int a;
 a = *ptr;
 return a * a;
}

第二個問題，看如下程式碼：

#include<iostream> 
#include<Windows.h> 
#include<assert.h> 
 
using namespace std; 
 
int main() 
{ 
 const int a = 2; 
 int *p = const_cast<int*>(&a); 
 *p = 3; 
 cout << a << endl; 
 system("pause"); 
 return 0; 
}

我們有理由的認為在記憶體當中a的值被修改為3，但是結果呢？ 我們來看一看

這不科學啊？？ 我們再開啟監視視窗看一下a的值.

我們都知道監視視窗看到的都是從記憶體當中拿到的，但是為什麼記憶體當中為3，打印出來就是2呢？ 我來解釋一下.

C++編譯器具有優化功能，當你定一個const的常量的時候，系統覺得它不會被改變了，於是做一個優化把該常量存到寄

存器當中，下次訪問的過程更快速一點. 所以當顯示視窗讀取資料的時候，他會直接去暫存器當中讀取資料.而不是去

記憶體，所以導致我們明明該掉了a的值，卻打印不出來.

這個時候該我們的volatile出馬了，往i前面加一個volatile之後就會解決這個問題，來看結果：

談談C++的volatile關鍵字以及常見的誤解

近期看到C++標準中對volatile關鍵字的定義，發現和java的volatile關鍵字完全不一樣，C++的volatile對併發程式設計基本沒有幫助。網上也看到很多關於volatile的誤解，於是決定寫這篇文章詳細解釋一下volatile的作用到底是什麼。

編譯器對程式碼的優化

在講volatile關鍵字之前，先講一下編譯器的優化。

int main() {
 int i = 0;
 i++;
 cout << "hello world" << endl;
}

按照程式碼，這個程式會在記憶體中預留int大小的空間，初始化這段記憶體為0，然後這段記憶體中的資料加1，最後輸出“hello world”到標準輸出中。但是根據這段程式碼編譯出來的程式（加-O2選項），不會預留int大小的記憶體空間，更不會對記憶體中的數字加1。他只會輸出“hello world”到標準輸出中。

其實不難理解，這個是編譯器為了優化程式碼，修改了程式的邏輯。實際上C++標準是允許寫出來的程式碼和實際生成的程式不一致的。雖說優化程式碼是件好事情，但是也不能讓編譯器任意修改程式邏輯，不然的話我們沒辦法寫可靠的程式了。所以C++對這種邏輯的改寫是有限制的，這個限制就是在編譯器修改邏輯後，程式對外界的IO依舊是不變的。怎麼理解呢？實際上我們可以把我們寫出來的程式看做是一個黑匣子，如果按照相同的順序輸入相同的輸入，他就每次都會以同樣的順序給出同樣的輸出。這裡的輸入輸出包括了標準輸入輸出、檔案系統、網路IO、甚至一些system call等等，所有程式外部的事物都包含在內。所以對於程式使用者來說，只要兩個黑匣子的輸入輸出是完全一致的，那麼這兩個黑匣子是一致的，所以編譯器可以在這個限制下任意改寫程式的邏輯。這個規則又叫as-if原則。

volatile關鍵字的作用

不知道有沒有注意到，剛剛提到輸入輸出的時候，並沒有提到記憶體，事實上，程式對自己記憶體的操作不屬於外部的輸入輸出。這也是為什麼在上述例子中，編譯器可以去除對i變數的操作。但是這又會出現一個麻煩，有些時候作業系統會把一些硬體對映到記憶體上，讓程式通過對記憶體的操作來操作這個硬體，比如說把磁碟空間對映到記憶體中。那麼對這部分記憶體的操作實際上就屬於對程式外部的輸入輸出了。對這部分記憶體的操作是不能隨便修改順序的，更不能忽略。這個時候volatile就可以派上用場了。按照C++標準，對於glvalue的volatile變數進行操作，與其他輸入輸出一樣，順序和內容都是不能改變的。這個結果就像是把對volatile的操作看做程式外部的輸入輸出一樣。（glvalue是值類別的一種，簡單說就是記憶體上分配有空間的物件，更詳細的請看我的另一篇文章。）

按照C++標準，這是volatile唯一的功能，但是在一些編譯器（如，MSVC）中，volatile還有執行緒同步的功能，但這就是編譯器自己的拓展了，並不能跨平臺應用。

對volatile常見的誤解

實際上“volatile可以線上程間同步”也是比較常見的誤解。比如以下的例子：

class AObject
{
public:
 void wait()
 {
 m_flag = false;
 while (!m_flag)
 {
 this_thread::sleep(1000ms);
 }
 }
 void notify()
 {
 m_flag = true;
 }

private:
 volatile bool m_flag;
};

AObject obj;

...

// Thread 1
...
obj.wait();
...

// Thread 2
...
obj.notify();
...

對volatile有誤解的人，或者對併發程式設計不瞭解的人可能會覺得這段邏輯沒什麼問題，可能會認為volatile保證了，wait()對m_flag的讀取，notify()對m_flag的寫入，所以Thread 1能夠正常醒來。實際上並不是這麼簡單，因為在多核CPU中，每個CPU都有自己的快取。快取中存有一部分記憶體中的資料，CPU要對記憶體讀取與儲存的時候都會先去操作快取，而不會直接對記憶體進行操作。所以多個CPU“看到”的記憶體中的資料是不一樣的，這個叫做記憶體可見性問題（memory visibility）。放到例子中就是，Thread 2修改了m_flag對應的記憶體，但是Thread 1在其他CPU核上執行，所以Thread 1不一定能看到Thread 2對m_flag做的更改。C++11開始，C++標準中有了執行緒的概念，C++標準規定了什麼情況下一個執行緒一定可以看到另一個執行緒做的記憶體的修改。而根據標準，上述例子中的Thread 1可能永遠看不到m_flag變成true，更嚴重的是，Thread 1對m_flag的讀取會導致Undefined Behavior。

從C++標準來說，這段程式碼是Undefined Behavior，既然是Undefined Behavior的話，是不是也可能正確執行？是的，熟悉MESI的應該會知道，Thread 2的修改導致快取變髒，Thread 1讀取記憶體會試圖獲取最新的資料，所以這段程式碼可以正常執行。那是不是就意味著我們可以放心使用volatile來做執行緒的同步？不是的，只是在這個例子能夠正確執行而已。我們對例子稍作修改，volatile就沒那麼好使了。

class AObject
{
public:
 void wait()
 {
 m_flag = false;
 while (!m_flag)
 {
 this_thread::sleep(1000ms);
 }
 }
 void notify()
 {
 m_flag = true;
 }

private:
 volatile bool m_flag;
};

AObject obj;
bool something = false;
... 

// Thread 1 
... 
obj.wait(); 
assert(something)
... 

// Thread 2 
... 
something = true;
obj.notify();
 ...

在以上程式碼中，Thread 1的assert語句可能會失敗。就如前文所說，C++編譯器在保證as-if原則下可以隨意打亂變數賦值的順序，甚至移除某個變數。所以上述例子中的“something = true"語句可能發生在obj.notify()之後。這樣的話，“assert(something)”就會失敗了。

那麼我們可不可能把something也變成volatile？如果something是volatile，我們確實能夠保證編譯出來的程式中的語句順序和原始碼一致，但我們仍然不能保證兩個語句是按照原始碼中的順序執行，因為現代CPU往往都有亂序執行的功能。所謂亂序執行，CPU會在保證程式碼正確執行的基礎上，調整指令的順序，加快程式的運算，更多細節我們不在這裡展開。我們如果單看Thread 2執行緒，something和m_flag這兩個變數的讀寫是沒有依賴關係的，而Thread 2執行緒看不到這兩個變數在其他執行緒上的依賴關係，所以CPU可能會打亂他們的執行順序，或者同時執行這兩個指令。結果就是，在Thread 1中，obj.wait()返回後，something可能仍然是false，assert失敗。當然，會不會出現這樣的狀況，實際上也和具體的CPU有關係。但是我們知道錯誤的程式碼可能會引起錯誤的結果，我們應該避免錯誤的寫法，而這個錯誤就在於誤用了volatile關鍵字，volatile可以避免優化、強制記憶體讀取的順序，但是volatile並沒有執行緒同步的語義，C++標準並不能保證它在多執行緒情況的正確性。

那麼用不了volatile，我們該怎麼修改上面的例子？C++11開始有一個很好用的庫，那就是atomic類模板，在<atomic>標頭檔案中，多個執行緒對atomic物件進行訪問是安全的，並且提供不同種類的執行緒同步。不同種類的執行緒同步非常複雜，要涉及到C++的記憶體模型與併發程式設計，我就不在此展開。它預設使用的是最強的同步，所以我們就使用預設的就好。以下為修改後的程式碼：

class AObject
{
public:
 void wait()
 {
 m_flag = false;
 while (!m_flag)
 {
 this_thread::sleep(1000ms);
 }
 }
 void notify()
 {
 m_flag = true;
 }

private:
 atomic<bool> m_flag;
};

只要把“volatile bool”替換為“atomic<bool>”就可以。<atomic>標頭檔案也定義了若干常用的別名，例如“atomic<bool>”就可以替換為“atomic_bool”。atomic模板過載了常用的運算子，所以atomic<bool>使用起來和普通的bool變數差別不大。