編譯器重排序優化
1. 非自動內存管理情況下怎麼做單例模式
懶漢式，線程不安全
當被問到要實現一個單例模式時，很多人的第一反應是寫出如下的代碼，包括教科書上也是這樣教我們的。
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static Singleton getInstance () {
if (instance == null ) {
instance = new Singleton();
}
return instance;
}
}
這段代碼簡單明了，而且使用了懶載入模式，但是卻存在致命的問題。當有多個線程並行調用 getInstance() 的時候，就會創建多個實例。也就是說在多線程下不能正常工作。
懶漢式，線程安全
為了解決上面的問題，最簡單的方法是將整個 getInstance() 方法設為同步（synchronized）。
public static synchronized Singleton getInstance () {
if (instance == null ) {
instance = new Singleton();
}
return instance;
}
雖然做到了線程安全，並且解決了多實例的問題，但是它並不高效。因為在任何時候只能有一個線程調用 getInstance() 方法。但是同步操作只需要在第一次調用時才被需要，即第一次創建單例實例對象時。這就引出了雙重檢驗鎖。
雙重檢驗鎖
雙重檢驗鎖模式（double checked locking pattern），是一種使用同步塊加鎖的方法。程序員稱其為雙重檢查鎖，因為會有兩次檢查 instance == null ，一次是在同步塊外，一次是在同步塊內。為什麼在同步塊內還要再檢驗一次？因為可能會有多個線程一起進入同步塊外的 if，如果在同步塊內不進行二次檢驗的話就會生成多個實例了。
public static Singleton getSingleton () {
if (instance == null ) { //Single Checked
synchronized (Singleton.class) {
if (instance == null ) { //Double Checked
instance = new Singleton();
}
}
}
return instance ;
}
這段代碼看起來很完美，很可惜，它是有問題。主要在於 instance = new Singleton() 這句，這並非是一個原子操作，事實上在 jvm 中這句話大概做了下面 3 件事情。
給 instance 分配內存
調用 Singleton 的構造函數來初始化成員變數
將instance對象指向分配的內存空間（執行完這步 instance 就為非 null 了）
但是在 jvm 的即時編譯器中存在指令重排序的優化。也就是說上面的第二步和第三步的順序是不能保證的，最終的執行順序可能是 1-2-3 也可能是 1-3-2。如果是後者，則在 3 執行完畢、2 未執行之前，被線程二搶佔了，這時 instance 已經是非 null 了（但卻沒有初始化），所以線程二會直接返回 instance，然後使用，然後順理成章地報錯。
我們只需要將 instance 變數聲明成 volatile 就可以了。
public class Singleton {
private volatile static Singleton instance; //聲明成 volatile
private Singleton (){}
public static Singleton getSingleton () {
if (instance == null ) {
synchronized (Singleton.class) {
if (instance == null ) {
instance = new Singleton();
}
}
}
return instance;
}
}
有些人認為使用 volatile 的原因是可見性，也就是可以保證線程在本地不會存有 instance 的副本，每次都是去主內存中讀取。但其實是不對的。使用 volatile 的主要原因是其另一個特性：禁止指令重排序優化。也就是說，在 volatile 變數的賦值操作後面會有一個內存屏障（生成的匯編代碼上），讀操作不會被重排序到內存屏障之前。比如上面的例子，取操作必須在執行完 1-2-3 之後或者 1-3-2 之後，不存在執行到 1-3 然後取到值的情況。從「先行發生原則」的角度理解的話，就是對於一個 volatile 變數的寫操作都先行發生於後面對這個變數的讀操作（這里的「後面」是時間上的先後順序）。
但是特別注意在 java 5 以前的版本使用了 volatile 的雙檢鎖還是有問題的。其原因是 java 5 以前的 JMM （java 內存模型）是存在缺陷的，即時將變數聲明成 volatile 也不能完全避免重排序，主要是 volatile 變數前後的代碼仍然存在重排序問題。這個 volatile 屏蔽重排序的問題在 java 5 中才得以修復，所以在這之後才可以放心使用 volatile。
相信你不會喜歡這種復雜又隱含問題的方式，當然我們有更好的實現線程安全的單例模式的辦法。
餓漢式 static final field
這種方法非常簡單，因為單例的實例被聲明成 static 和 final 變數了，在第一次載入類到內存中時就會初始化，所以創建實例本身是線程安全的。
public class Singleton {
//類載入時就初始化
private static final Singleton instance = new Singleton();
private Singleton (){}
public static Singleton getInstance (){
return instance;
}
}
這種寫法如果完美的話，就沒必要在啰嗦那麼多雙檢鎖的問題了。缺點是它不是一種懶載入模式（lazy initialization），單例會在載入類後一開始就被初始化，即使客戶端沒有調用 getInstance()方法。餓漢式的創建方式在一些場景中將無法使用：譬如 Singleton 實例的創建是依賴參數或者配置文件的，在 getInstance() 之前必須調用某個方法設置參數給它，那樣這種單例寫法就無法使用了。
靜態內部類 static nested class
我比較傾向於使用靜態內部類的方法，這種方法也是《Effective java》上所推薦的。
public class Singleton {
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton (){}
public static final Singleton getInstance () {
return SingletonHolder.INSTANCE;
}
}
這種寫法仍然使用jvm本身機制保證了線程安全問題；由於 SingletonHolder 是私有的，除了 getInstance() 之外沒有辦法訪問它，因此它是懶漢式的；同時讀取實例的時候不會進行同步，沒有性能缺陷；也不依賴 jdk 版本。
枚舉 Enum
用枚舉寫單例實在太簡單了！這也是它最大的優點。下面這段代碼就是聲明枚舉實例的通常做法。
public enum EasySingleton{
INSTANCE;
}
我們可以通過EasySingleton.INSTANCE來訪問實例，這比調用getInstance()方法簡單多了。創建枚舉默認就是線程安全的，所以不需要擔心double checked locking，而且還能防止反序列化導致重新創建新的對象。但是還是很少看到有人這樣寫，可能是因為不太熟悉吧。
總結
一般來說，單例模式有五種寫法：懶漢、餓漢、雙重檢驗鎖、靜態內部類、枚舉。上述所說都是線程安全的實現，文章開頭給出的第一種方法不算正確的寫法。
2. 有沒有講編譯器如何優化代碼的書，有關C語言的，推薦一下
代碼優化啊，現代編譯器採用優化方法都差不多，看編譯原理就行了，編譯原理也就後面會用一個小章帶過。常用的比如：循環展開，寄存器使用優化，常量直接算出來，除法優化，分支判斷優化等等很多很多。據說除法優化後和乘法相比慢不了多少，沒測過。
其實真正應該看的是計算機組成原理，當你理解了計算機工作機制後，這些優化方法都很容易理解，而且你也會發現，程序的運行效率的提高，一方面要靠處理器，比如流水線，超標量，多級緩沖等技術，另一方面就是編譯器的優化。
3. SET I1=100 指令的含義是將100的值賦給()
摘要 重排序後， a 的兩次操作被放到一起，指令執行情況變為 Load a、Set to 100、Set to 110、 Store a。下面和 b 相關的指令不變，仍對應 Load b、 Set to 5、Store b。
4. C++編譯器（Dev-C）是否會自動內聯函數 對於什麼樣的函數即使標記inline也會拒絕內聯
G++編譯器是否會自動進行內聯函數？
G++編譯器是很先進的，編譯的時候如果開啟優化，G++會代碼進行各種優化，如：對合適的函數進行內聯（即便是沒有添加inline關鍵字），對某些函數直接對其進行求值，除此之外G++編譯器還可以對代碼進行重排序 等等。編譯器比你更了解硬體，所以只要允許它優化，他會盡量進行優化。你使用的Dev C++集成開發環境使用的c++編譯器就是G++。
什麼樣的函數即使標記inline也無法內聯？
比如函數體太大、太復雜的話（比如包含多重循環、包含遞歸調用），對其進行內聯得不償失，這時編譯器就會忽略inline關鍵字，VC++編譯器提供了強制內聯函數的關鍵字，除非你非常了解硬體，不然最好讓編譯器來處。編譯不對那些函數進行內聯要看具體的編譯器實現了。
inline關鍵字的有哪些作用？
inline關鍵字可以提示編譯器對某個函數進行內聯，並且強制函數使用內部鏈接。比如說你在頭文件定義了某個函數，為了防止多重定義，你可以添加inline關鍵字來防止多重定義錯誤。
如果對硬體不是很了解，底層的代碼優化還是留給編譯器來處理。
看看下面的幾個編譯器優化函數的例子：
1.編譯器直接對函數求值：
解釋一下：
第一條和第二天指令分別將b和a的地址載入到寄存器rdx和rcx中
第三條指令將b的值載入到eax寄存器中
第四條指令將34存入b中
第五條指令將eax的值加1（eax保存了之前b的值）
第六條指令將eax的值存入a中
可以看出編譯器將函數的兩條語句換了位置，這種優化主要是優化代碼的執行速度，有的CPU內存讀寫操作的的開銷不一樣，所以重新排序一下某些代碼能夠提高程序執行速度。
5. C語言中Valatile關鍵字有什麼用
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的條件不會當作無條件真。
3 對volatile變數的讀寫不會被優化掉。如果你對一個變數賦值但後面沒用到，編譯器常常可以省略那個賦值操作，然而對Memory Mapped IO的處理是不能這樣優化的。
前面有人說volatile可以保證對內存操作的原子性，這種說法不大准確，其一，x86需要LOCK前綴才能在SMP下保證原子性，其二，RISC根本不能對內存直接運算，要保證原子性得用別的方法，如atomic_inc。
對於jiffies，它已經聲明為volatile變數，我認為直接用jiffies++就可以了，沒必要用那種復雜的形式，因為那樣也不能保證原子性。
你可能不知道在Pentium及後續CPU中，下面兩組指令
inc jiffies
;;
mov jiffies, %eax
inc %eax
mov %eax, jiffies
作用相同，但一條指令反而不如三條指令快。
三、編譯器優化 → C關鍵字volatile → memory破壞描述符zz
「memory」比較特殊，可能是內嵌匯編中最難懂部分。為解釋清楚它，先介紹一下編譯器的優化知識，再看C關鍵字volatile。最後去看該描述符。
1、編譯器優化介紹
內存訪問速度遠不及CPU處理速度，為提高機器整體性能，在硬體上引入硬體高速緩存Cache，加速對內存的訪問。另外在現代CPU中指令的執行並不一定嚴格按照順序執行，沒有相關性的指令可以亂序執行，以充分利用CPU的指令流水線，提高執行速度。以上是硬體級別的優化。再看軟體一級的優化：一種是在編寫代碼時由程序員優化，另一種是由編譯器進行優化。編譯器優化常用的方法有：將內存變數緩存到寄存器；調整指令順序充分利用CPU指令流水線，常見的是重新排序讀寫指令。對常規內存進行優化的時候，這些優化是透明的，而且效率很好。由編譯器優化或者硬體重新排序引起的問題的解決辦法是在從硬體（或者其他處理器）的角度看必須以特定順序執行的操作之間設置內存屏障（memory barrier），linux 提供了一個宏解決編譯器的執行順序問題。
void Barrier(void)
這個函數通知編譯器插入一個內存屏障，但對硬體無效，編譯後的代碼會把當前CPU寄存器中的所有修改過的數值存入內存，需要這些數據的時候再重新從內存中讀出。
2、C語言關鍵字volatile
C語言關鍵字volatile（注意它是用來修飾變數而不是上面介紹的__volatile__）表明某個變數的值可能在外部被改變，因此對這些變數的存取不能緩存到寄存器，每次使用時需要重新存取。該關鍵字在多線程環境下經常使用，因為在編寫多線程的程序時，同一個變數可能被多個線程修改，而程序通過該變數同步各個線程，例如：
DWORD __stdcall threadFunc(LPVOID signal)
{
int* intSignal=reinterpret_cast<int*>(signal);
*intSignal=2;
while(*intSignal!=1)
sleep(1000);
return 0;
}
該線程啟動時將intSignal 置為2，然後循環等待直到intSignal 為1 時退出。顯然intSignal的值必須在外部被改變，否則該線程不會退出。但是實際運行的時候該線程卻不會退出，即使在外部將它的值改為1，看一下對應的偽匯編代碼就明白了：
mov ax,signal
label:
if(ax!=1)
goto label
對於C編譯器來說，它並不知道這個值會被其他線程修改。自然就把它cache在寄存器裡面。記住，C 編譯器是沒有線程概念的！這時候就需要用到volatile。volatile 的本意是指：這個值可能會在當前線程外部被改變。也就是說，我們要在threadFunc中的intSignal前面加上volatile關鍵字，這時候，編譯器知道該變數的值會在外部改變，因此每次訪問該變數時會重新讀取，所作的循環變為如下面偽碼所示：
label:
mov ax,signal
if(ax!=1)
goto label
3、Memory
有了上面的知識就不難理解Memory修改描述符了，Memory描述符告知GCC：
1）不要將該段內嵌匯編指令與前面的指令重新排序；也就是在執行內嵌匯編代碼之前，它前面的指令都執行完畢
2）不要將變數緩存到寄存器，因為這段代碼可能會用到內存變數，而這些內存變數會以不可預知的方式發生改變，因此GCC插入必要的代碼先將緩存到寄存器的變數值寫回內存，如果後面又訪問這些變數，需要重新訪問內存。
如果匯編指令修改了內存，但是GCC 本身卻察覺不到，因為在輸出部分沒有描述，此時就需要在修改描述部分增加「memory」，告訴GCC 內存已經被修改，GCC 得知這個信息後，就會在這段指令之前，插入必要的指令將前面因為優化Cache 到寄存器中的變數值先寫回內存，如果以後又要使用這些變數再重新讀取。
使用「volatile」也可以達到這個目的，但是我們在每個變數前增加該關鍵字，不如使用「memory」方便。
6. java編譯器的代碼優化問題
理論上的就不說了，你自己搜也能搜到很多。
舉個例子，你從一個方法a調用了另一個方法b。
我們知道，在a和b之中是可以創建相同名稱的變數的，比如都有int i = 0;這句話。這種現象的根本原因在於，方法的調用會產生中斷，中斷產生後，cpu會做現場保護，包括把變數等進行壓棧操作，即把方法a的相關資源進行了壓棧，而方法b的相關資源放在棧頂，只有棧頂資源可以與cpu交互（就把方法a中的變數i保護起來），當方法b結束後出棧，a就又回到了棧頂，並獲取了方法b運行的結果，然後繼續運行。
哎，有些啰嗦了。方法的調用、中斷、壓棧出棧等等這些操作你說一點不消耗資源吧，那是不可能的，多少都會消耗一些，雖然很非常十分微不足道。那麼編譯器的優化過程，我知道的其作用之一，就是會把這些做一個優化。原本方法a一共10句話，你偏要只寫1句，然後第2句寫成方法b，第3句寫成方法c。。。。。，然後依次嵌套調用。這樣的源代碼，編譯器優化後，就跟你直接寫10句是一個結果，即做了一定程度上的優化。
7. 什麼是指令重排
什麼是指令重排序？
有兩個層面：
**在虛擬機層面，**為了盡可能減少內存操作速度遠慢於CPU運行速度所帶來的CPU空置的影響，虛擬機會按照自己的一些規則(這規則後面再敘述)將程序編寫順序打亂——即寫在後面的代碼在時間順序上可能會先執行，而寫在前面的代碼會後執行——以盡可能充分地利用CPU。拿上面的例子來說：假如不是a=1的操作，而是a=new byte1024*1024，那麼它會運行地很慢，此時CPU是等待其執行結束呢，還是先執行下面那句flag=true呢？顯然，先執行flag=true可以提前使用CPU，加快整體效率，當然這樣的前提是不會產生錯誤(什麼樣的錯誤後面再說)。雖然這里有兩種情況：後面的代碼先於前面的代碼開始執行；前面的代碼先開始執行，但當效率較慢的時候，後面的代碼開始執行並先於前面的代碼執行結束。不管誰先開始，總之後面的代碼在一些情況下存在先結束的可能。
**在硬體層面，**CPU會將接收到的一批指令按照其規則重排序，同樣是基於CPU速度比緩存速度快的原因，和上一點的目的類似，只是硬體處理的話，每次只能在接收到的有限指令范圍內重排序，而虛擬機可以在更大層面、更多指令范圍內重排序。硬體的重排序機制參見《從JVM並發看CPU內存指令重排序(Memory Reordering)》
Java提供了兩個關鍵字volatile和synchronized來保證多線程之間操作的有序性,volatile關鍵字本身通過加入內存屏障來禁止指令的重排序，而synchronized關鍵字通過一個變數在同一時間只允許有一個線程對其進行加鎖的規則來實現。
在單線程程序中，不會發生「指令重排」和「工作內存和主內存同步延遲」現象，只在多線程程序中出現。
1）編譯器優化的重排序。編譯器在不改變單線程程序語義的前提下，可以重新安排語句的執行順序。
2）指令級並行的重排序。現代處理器採用了指令級並行技術（Instruction-LevelParallelism，ILP）來將多條指令重疊執行。如果不存在數據依賴性，處理器可以改變語句對應機器指令的執行順序。
3）內存系統的重排序。由於處理器使用緩存和讀/寫緩沖區，這使得載入和存儲操作看上去可能是在亂序執行
8. 編譯器優化怎麼定義
常見的優化和變新有：函數內嵌（inlining），無用代碼刪除（Dead code elimination），標准化循環結構（loop normalization），循環體展開（loop unrolling），循環體合並，分裂（loop fusion，loop fission），數組填充（array padding），等等。 優化和變形的目的是減少代碼的長度，提高內存（memory），緩存（cache）的使用率，減少讀寫磁碟，訪問網路數據的頻率。更高級的優化甚至可以把序列化的代碼（serial code）變成並行運算，多線程的代碼（parallelized，multi-threaded code）。
機器代碼的生成是優化變型後的中間代碼轉換成機器指令的過程。現代編譯器主要採用生成匯編代碼（assembly code）策略，而不直接生成二進制的目標代碼（binary object code）。即使在代碼生成階段，高級編譯器仍然要做很多分析，優化，變形工作。例如如何分配寄存器（register allocatioin），如何選擇合適的機器指令，如何合並幾句代碼成一句等等。
9. Java 語言中的 volatile 和synchronized有什麼區別
被volatile修飾過的對象保證了對線程的可見性，對於非volatile修飾的對象，都是從共享內存載入到緩存，線程都是從緩存中讀取的對象，當一個線程對一個非volatile的對象賦值的時候，同樣是先寫到緩存，然後在同步到共享內存，這樣就無法保證每個線程從共享內存讀取的數據是最新的。而被volatile修飾過的對象，線程是直接從共享內存中讀取的，寫入也一樣。編譯器在編譯期間會對指令進行優化的重排序，使用volatile的就不會進行重排序
10. java指令重排序,happens-before的問題
重排序有一條原則，就是單線程運行這段代碼不能影響得到的結果（這段代碼雖然另起一個線程，但本身是由一個線程「引發」的）所以順序沒變，這也是很多人試的結果——沒變。但提到重排序理論上又覺得可能變，所以以上解釋算是我個人理解吧。重排序旨在盡可能的利用流水思想，復用寄存器減少讀寫，但最根本的還是要保障正確性，否則效率高沒一點意義。編譯器的行為應該還是慎重的（這里的例子應該也是編譯時重排序）