深入講解C語言編程中volatile修飾符的作用_Swift

volatile提醒編譯器它後面所定義的變數隨時都有可能改變，因此編譯後的程式每次需要儲存或讀取這個變數的時候，都會直接從變數地址中讀取資料。如果沒有volatile關鍵字，則編譯器可能最佳化讀取和儲存，可能暫時使用寄存器中的值，如果這個變數由別的程式更新了的話，將出現不一致的現象。下面舉例說明。在DSP開發中，經常需要等待某個事件的觸發，所以經常會寫出這樣的程式：

short flag;void test(){do1();while(flag==0);do2();}

    這段程式等待記憶體變數flag的值變為1(懷疑此處是0,有點疑問,)之後才運行do2()。變數flag的值由別的程式更改，這個程式可能是某個硬體中斷服務程式。例如：如果某個按鈕按下的話，就會對DSP產生中斷，在按鍵中斷程式中修改flag為1，這樣上面的程式就能夠得以繼續運行。但是，編譯器並不知道flag的值會被別的程式修改，因此在它進行最佳化的時候，可能會把flag的值先讀入某個寄存器，然後等待那個寄存器變為1。如果不幸進行了這樣的最佳化，那麼while迴圈就變成了死迴圈，因為寄存器的內容不可能被中斷服務程式修改。為了讓程式每次都讀取真正flag變數的值，就需要定義為如下形式：

volatile short flag;

    需要注意的是，沒有volatile也可能能正常運行，但是可能修改了編譯器的最佳化層級之後就又不能正常運行了。因此經常會出現debug版本正常，但是release版本卻不能正常的問題。所以為了安全起見，只要是等待別的程式修改某個變數的話，就加上volatile關鍵字。

volatile的本意是“易變的”
      由於訪問寄存器的速度要快過RAM，所以編譯器一般都會作減少存取外部RAM的最佳化。比如：

static int i=0;int main(void){...while (1){if (i) do_something();}}/* Interrupt service routine. */void ISR_2(void){i=1;}

    程式的本意是希望ISR_2中斷產生時，在main當中調用do_something函數，但是，由於編譯器判斷在main函數裡面沒有修改過i，因此可能只執行一次對從i到某寄存器的讀操作，然後每次if判斷都只使用這個寄存器裡面的“i副本”，導致do_something永遠也不會被調用。如果變數加上volatile修飾，則編譯器保證對此變數的讀寫操作都不會被最佳化（肯定執行）。此例中i也應該如此說明。
    一般說來，volatile用在如下的幾個地方：
1、中斷服務程式中修改的供其它程式檢測的變數需要加volatile；
2、多任務環境下各任務間共用的標誌應該加volatile；
3、儲存空間映射的硬體寄存器通常也要加volatile說明，因為每次對它的讀寫都可能由不同意義；
另外，以上這幾種情況經常還要同時考慮資料的完整性（相互關聯的幾個標誌讀了一半被打斷了重寫），在1中可以通過關中斷來實現，2中可以禁止任務調度，3中則只能依靠硬體的良好設計了。
volatile 的深層次含義
     volatile總是與最佳化有關，編譯器有一種技術叫做資料流分析，剖析器中的變數在哪裡賦值、在哪裡使用、在哪裡失效，分析結果可以用於常量合并，常量傳播等最佳化，進一步可以無作用程式碼消除。但有時這些最佳化不是程式所需要的，這時可以用volatile關鍵字禁止做這些最佳化，volatile的字面含義是易變的，它有下面的作用： 

1. 不會在兩個操作之間把volatile變數緩衝在寄存器中。在多任務、中斷、甚至setjmp環境下，變數可能被其他的程式改變，編譯器自己無法知道，volatile就是告訴編譯器這種情況。
2. 不做常量合并、常量傳播等最佳化，所以像下面的代碼：

volatile int i = 1;if (i > 0) ...

if的條件不會當作無條件真。

• 對volatile變數的讀寫不會被最佳化掉。如果你對一個變數賦值但後面沒用到，編譯器常常可以省略那個賦值操作，然而對Memory Mapped IO的處理是不能這樣最佳化的。 

 前面有人說volatile可以保證對記憶體操作的原子性，這種說法不大準確，其一，x86需要LOCK首碼才能在SMP下保證原子性，其二，RISC根本不能對記憶體直接運算，要保證原子性得用別的方法，如atomic_inc。

    對於jiffies，它已經聲明為volatile變數，我認為直接用jiffies++就可以了，沒必要用那種複雜的形式，因為那樣也不能保證原子性。
    你可能不知道在Pentium及後續CPU中，下面兩組指令

inc jiffies ;;mov jiffies, %eaxinc %eaxmov %eax, jiffies

作用相同，但一條指令反而不如三條指令快。
編譯器最佳化 → C關鍵字volatile → memory破壞描述符zz

    “memory”比較特殊，可能是內嵌彙編中最難懂部分。為解釋清楚它，先介紹一下編譯器的最佳化知識，再看C關鍵字volatile。最後去看該描述符。
編譯器最佳化介紹 
     記憶體訪問速度遠不及CPU處理速度，為提高機器整體效能，在硬體上引入硬體快取Cache，加速對記憶體的訪問。另外在現代CPU中指令的執行並不一定嚴格按照順序執行，沒有相關性的指令可以亂序執行，以充分利用CPU的指令流水線，提高執行速度。以上是硬體層級的最佳化。再看軟體一級的最佳化：一種是在編寫代碼時由程式員最佳化，另一種是由編譯器進行最佳化。編譯器最佳化常用的方法有：將記憶體變數緩衝到寄存器；調整指令順序充分利用CPU指令流水線，常見的是重新排序讀寫指令。對常規記憶體進行最佳化的時候，這些最佳化是透明的，而且效率很好。由編譯器最佳化或者硬體重新排序引起的問題的解決辦法是在從硬體（或者其他處理器）的角度看必須以特定順序執行的操作之間設定記憶體屏障（memory barrier），linux 提供了一個宏解決編譯器的執行順序問題。
void Barrier(void)
     這個函數通知編譯器插入一個記憶體屏障，但對硬體無效，編譯後的代碼會把當前CPU寄存器中的所有修改過的數值存入記憶體，需要這些資料的時候再重新從記憶體中讀出。
Memory 
      有了上面的知識就不難理解Memory修改描述符了，Memory描述符告知GCC：
1）不要將該段內嵌彙編指令與前面的指令重新排序；也就是在執行內嵌彙編代碼之前，它前面的指令都執行完畢
2）不要將變數緩衝到寄存器，因為這段代碼可能會用到記憶體變數，而這些記憶體變數會以不可預知的方式發生改變，因此GCC插入必要的代碼先將緩衝到寄存器的變數值寫回記憶體，如果後面又訪問這些變數，需要重新訪問記憶體。
     如果彙編指令修改了記憶體，但是GCC 本身卻察覺不到，因為在輸出部分沒有描述，此時就需要在修改描述部分增加“memory”，告訴GCC 記憶體已經被修改，GCC 得知這個資訊後，就會在這段指令之前，插入必要的指令將前面因為最佳化Cache 到寄存器中的變數值先寫回記憶體，如果以後又要使用這些變數再重新讀取。
     使用“volatile”也可以達到這個目的，但是我們在每個變數前增加該關鍵字，不如使用“memory”方便。

volatile的重要性對於搞嵌入式的程式員來說是不言而喻的，對於volatile的瞭解程度常常被不少公司在招聘嵌入式編程人員面試的時候作為衡量一個應聘者是否合格的參考標準之一，為什麼volatile如此的重要呢？這是因為嵌入式的編程人員要經常同中斷、底層硬體等打交道，而這些都用到volatile，所以說嵌入式程式員必須要掌握好volatile的使用。

其實就象讀者所熟悉的const一樣，volatile是一個類型修飾符。在開始講解volatile之前我們先來講解下接下來要用到的一個函數，知道如何使用該函數的讀者可以跳過該函數的講解部分。

原型：

int gettimeofday ( struct timeval * tv , struct timezone * tz )；

標頭檔

#include <sys/time.h>

功能：擷取目前時間

傳回值：如果成功返回0，失敗返回－1，錯誤碼存於errno中。

gettimeofday()會把目前的時間用tv所指的結構返回，當地時區的資訊則放到tz所指的結構中。
timeval結構定義為:

struct timeval{ long tv_sec;  long tv_usec; };

timezone 結構定義為:

struct timezone{ int tz_minuteswest;  int tz_dsttime; };

先來說說timeval結構體，其中的tv_sec存放的是秒，而tv_usec存放的是微秒。其中的timezone成員變數我們很少使用，在此簡單的說說它在gettimeofday()函數中的作用是把當地時區的資訊則放到tz所指的結構中，在其中tz_minuteswest變數裡存放的是和Greenwich 時間差了多少分鐘，tz_dsttime日光節約時間的狀態。我們在此主要的是關注前一個成員變數timeval，後一個我們在此不使用，所以使用gettimeofday()函數的時候我們把有一個參數設定為NULL，下面先來看看一段簡單的代碼。

#include <stdio.h>#include <sys/time.h>int main(int argc, char * argv[]){ struct timeval start,end; gettimeofday( &start, NULL ); /*測試起始時間*/ double timeuse; int j; for(j=0;j<1000000;j++) ; gettimeofday( &end, NULL ); /*測試終止時間*/ timeuse = 1000000 * ( end.tv_sec - start.tv_sec ) + end.tv_sec - start.tv_sec ; timeuse /= 1000000;printf("已耗用時間為：%f\n",timeuse); return 0;}root@ubuntu:/home# ./p

已耗用時間為：

0.002736

現在來簡單的分析下代碼，通過end.tv_sec - start.tv_sec 我們得到了終止時間跟起始時間以秒為單位的時間間隔，然後使用end.tv_sec - start.tv_sec 得到終止時間跟起始時間以微妙為單位的時間間隔。因為時間單位的原因，所以我們在此對於( end.tv_sec - start.tv_sec ) 得到的結果乘以1000000轉換為微秒進行計算，之後再使用timeuse /= 1000000;將其轉換為秒。現在瞭解了如何通過gettimeofday()函數來測試start到end代碼之間的已耗用時間，那麼我們現在接下來看看volatile修飾符。

通常在代碼中我們為了防止一個變數在意想不到的情況下被改變，我們會將變數定義為volatile，這從而就使得編譯器就不會自作主張的去“動”這個變數的值了。準確點說就是每次在用到這個變數時必須每次都重新從記憶體中直接讀取這個變數的值，而不是使用儲存在寄存器裡的備份。

在舉例之前我們先大概的說下Debug和Release 模式下編譯方式的區別，Debug 通常稱為調試版本，它包含調試資訊，並且不作任何最佳化，便於程式員偵錯工具。Release 稱為發布版本，它往往是進行了各種最佳化，使得程式在代碼大小和運行速度上都是最優的，以便使用者很好地使用。大致的知道了Debug和Release的區別之後，我們下面來看看一段代碼。

#include <stdio.h>void main(){int a=12;printf("a的值為:%d\n",a);__asm {mov dword ptr [ebp-4], 0h}int b = a;printf("b的值為:%d\n",b);}

分析下上面的代碼，我們使用了一句__asm {mov dword ptr [ebp-4], 0h}來修改變數a在記憶體中的值。前面已經講解了Debug和Release 編譯方式的區別，那麼我們現在來對比看下結果。註：使用vc6編譯運行，如無特殊說明，均在linux環境下編譯運行。讀者自己在編譯的時候別忘了選擇編譯啟動並執行模式。

使用Debug模式的結果為：

a的值為:12 b的值為:0 Press any key to continue 

使用Release模式的結果為：

a的值為:12 b的值為:12 Press any key to continue 

看看上面的運行結果我們發現在Release模式進行了最佳化之後b的值為了12，但是使用Debug模式的時候b的值為0。為什麼會出現這樣的情況呢？我們先不說答案，再來看看下面一段代碼。註：使用vc6編譯運行

#include <stdio.h>  void main() { int volatile a=12; printf("a的值為:%d\n",a); __asm {mov dword ptr [ebp-4], 0h} int b = a; printf("b的值為:%d\n",b); } 

使用Debug模式的結果為：

a的值為:12 b的值為:0 Press any key to continue 

使用Release模式的結果為：

a的值為:12 b的值為:0 Press any key to continue 

我們發現這種情況下不管使用Debug模式還是Release模式都是一樣的結果。現在我們就來分析下，在此之前我們先說了Debug和Release 模式下編譯方式的區別。

先分析上一段代碼，由於在Debug模式下我們並沒有對代碼進行最佳化，所以對於在代碼中每次使用a值得時候都是從它的記憶體位址直接讀取的，所以在我們使用了__asm {mov dword ptr [ebp-4], 0h}語句改變了a的值之後，接下來使用a值的時候從記憶體中直接讀取，所以得到的是更新後的a值；但是當我們在Release模式下啟動並執行時候，發現b的值為a之前的值，而不是我們更新後的a值，這是由於編譯器在最佳化的過程中做了最佳化處理。編譯器發現在對a賦值之後沒有再次改變a的值，所以編譯器把a的值備份在了一個寄存器中，在之後的操作中我們再次使用a值的時候就直接操作這個寄存器，而不去讀取a的記憶體位址，因為讀取寄存器的速度要快於直接讀取記憶體的速度。這就使得了讀到的a值為之前的12。而不是更新後的0。

第二段代碼中我們使用了一個volatile修飾符，這種情況下不管在什麼模式下都得到的是更新後的a的值，因為volatile修飾符的作用就是告訴編譯器不要對它所修飾的變數進行任何的最佳化，每次取值都要直接從記憶體位址得到。從這兒我們可以看出，對於我們代碼中的那些易變數，我們最好使用volatile修飾，以此來得到每次對其進行更新後的值。為了加深下大家的印象我們再來看看下面一段代碼。

#include <stdio.h> #include <sys/time.h>  int main(int argc, char * argv[]) {  struct timeval start,end;  gettimeofday( &start, NULL ); /*測試起始時間*/  double timeuse;  int j;  for(j=0;j<10000000;j++)   ;  gettimeofday( &end, NULL ); /*測試終止時間*/  timeuse = 1000000 * ( end.tv_sec - start.tv_sec ) + end.tv_usec -start.tv_usec;  timeuse /= 1000000; printf("已耗用時間為：%f\n",timeuse);   return 0;  } 

與之前我們測試時間的代碼一樣，我們只是增大了for()迴圈的次數。

先來看看我們不使用最佳化的結果：

root@ubuntu:/home# gcc time.c -o p root@ubuntu:/home# ./p 已耗用時間為：0.028260 

使用了最佳化的運行結果：

root@ubuntu:/home# gcc -o p time.c -O2 root@ubuntu:/home# ./p 已耗用時間為：0.000001 

從結果顯然可以看出差距如此之大，但是如果我們在上面的代碼中修改一下int j為int  volatile j之後再來看看如下代碼：

#include <stdio.h> #include <sys/time.h>  int main(int argc, char * argv[]) {  struct timeval start,end;  gettimeofday( &start, NULL ); /*測試起始時間*/  double timeuse;  int volatile j;  for(j=0;j<10000000;j++)   ;  gettimeofday( &end, NULL ); /*測試終止時間*/  timeuse = 1000000 * ( end.tv_sec - start.tv_sec ) + end.tv_usec -start.tv_usec;  timeuse /= 1000000; printf("已耗用時間為：%f\n",timeuse);   return 0;  } 

先來看看我們不使用最佳化的運行結果為：

root@ubuntu:/home# gcc time.c -o p root@ubuntu:/home# ./p 已耗用時間為：0.027647 

使用了最佳化的運行結果為：

root@ubuntu:/home# gcc -o p time.c -O2 root@ubuntu:/home# ./p 已耗用時間為：0.027390 

我們發現此時此刻不管是否使用最佳化語句運行，時間幾乎沒有變化，只是有微小的差異，這微小的差異是由於電腦本身所導致的。所以我們通過對於上面一個沒有使用volatile和下面一個使用了volatile的對比結果可知，使用了volatile的變數在使用最佳化語句是for()迴圈並沒有得到最佳化，因為for()迴圈執行的是一個空操作，那麼通常情況下使用了最佳化語句使得這個for()迴圈被最佳化掉，根本就不執行。就好比編譯器在編譯的過程中將i的值設定為大於或者等於10000000的一個數，使得for()迴圈語句不會執行。但是由於我們使用了volatile，使得編譯器就不會自作主張的去動我們的i值，所以迴圈體得到了執行。舉這個例子的原因是要讓讀者牢記，如果我們定義了volatile變數，那麼它就不會被編譯器所最佳化。

當然volatile還有那些值得注意的地方呢？由於訪問寄存器的速度要快過直接存取記憶體的速度，所以編譯器一般都會作減少對於記憶體的訪問，但是如果將變數加上volatile修飾，則編譯器保證對此變數的讀寫操作都不會被最佳化。這樣說可能有些抽象了，再看看下面的代碼，在此就簡要的寫出幾步了。

main(){  int i=o;  while(i==0)  {     ……  }}

分析以上代碼，如果我們沒有在while迴圈體結構裡面改變i的值，編譯器在編譯的過程中就會將i的值備份到一個寄存器中，每次執行判斷語句時就從該寄存器取值，那麼這將是一個死迴圈，但是如果我們做如下的修改：

main(){  int volatile i=o;  while(i==0)  {     ……  }}

我們在i的前面加上了一個volatile，假設while()迴圈體裡面執行的是跟上一個完全一樣的操作，但是這個時候就不能說是一個死迴圈了，因為編譯器不會再對我們的i值進行"備份"操作了，每次執行判斷的時候都會直接從i的記憶體位址中讀取，一旦其值發生變化就退出迴圈體。

最後給出一點就是在實際使用中volatile的使用的場合大致有以下幾點：

1、中斷服務程式中修改的供其它程式檢測的變數需要加volatile；

2、多任務環境下各任務間共用的標誌應該加volatile；

3、儲存空間映射的硬體寄存器通常也要加volatile說明，因為每次對它的讀寫都可能有不同意義。