轉自http://blog.csdn.net/lishenglong666/article/details/8557215

魚還是熊掌：淺談多程序多執行緒的選擇

關於多程序和多執行緒，教科書上最經典的一句話是“程序是資源分配的最小單位，執行緒是CPU排程的最小單位”，這句話應付考試基本上夠了，但如果在工作中遇到類似的選擇問題，那就沒有這麼簡單了，選的不好，會讓你深受其害。

經常在網路上看到有的XDJM問“多程序好還是多執行緒好？”、“Linux下用多程序還是多執行緒？”等等期望一勞永逸的問題，我只能說：沒有最好，只有更好。根據實際情況來判斷，哪個更加合適就是哪個好。

我們按照多個不同的維度，來看看多執行緒和多程序的對比（注：因為是感性的比較，因此都是相對的，不是說一個好得不得了，另外一個差的無法忍受）。

對比維度	多程序	多執行緒	總結
資料共享、同步	資料共享複雜，需要用IPC；資料是分開的，同步簡單	因為共享程序資料，資料共享簡單，但也是因為這個原因導致同步複雜	各有優勢
記憶體、CPU	佔用記憶體多，切換複雜，CPU利用率低	佔用記憶體少，切換簡單，CPU利用率高	執行緒佔優
建立銷燬、切換	建立銷燬、切換複雜，速度慢	建立銷燬、切換簡單，速度很快	執行緒佔優
程式設計、除錯	程式設計簡單，除錯簡單	程式設計複雜，除錯複雜	程序佔優
可靠性	程序間不會互相影響	一個執行緒掛掉將導致整個程序掛掉	程序佔優
分散式	適應於多核、多機分散式；如果一臺機器不夠，擴充套件到多臺機器比較簡單	適應於多核分散式	程序佔優

看起來比較簡單，優勢對比上是“執行緒 3.5 v 2.5 程序”，我們只管選執行緒就是了？

呵呵，有這麼簡單我就不用在這裡浪費口舌了，還是那句話，沒有絕對的好與壞，只有哪個更加合適的問題。我們來看實際應用中究竟如何判斷更加合適。

1）需要頻繁建立銷燬的優先用執行緒

原因請看上面的對比。

這種原則最常見的應用就是Web伺服器了，來一個連線建立一個執行緒，斷了就銷燬執行緒，要是用程序，建立和銷燬的代價是很難承受的

2）需要進行大量計算的優先使用執行緒

所謂大量計算，當然就是要耗費很多CPU，切換頻繁了，這種情況下執行緒是最合適的。

這種原則最常見的是影象處理、演算法處理。

3）強相關的處理用執行緒，弱相關的處理用程序

什麼叫強相關、弱相關？理論上很難定義，給個簡單的例子就明白了。

一般的Server需要完成如下任務：訊息收發、訊息處理。“訊息收發”和“訊息處理”就是弱相關的任務，而“訊息處理”裡面可能又分為“訊息解碼”、“業務處理”，這兩個任務相對來說相關性就要強多了。因此“訊息收發”和“訊息處理”可以分程序設計，“訊息解碼”、“業務處理”可以分執行緒設計。

當然這種劃分方式不是一成不變的，也可以根據實際情況進行調整。

4）可能要擴充套件到多機分佈的用程序，多核分佈的用執行緒

原因請看上面對比。

5）都滿足需求的情況下，用你最熟悉、最拿手的方式

至於“資料共享、同步”、“程式設計、除錯”、“可靠性”這幾個維度的所謂的“複雜、簡單”應該怎麼取捨，我只能說：沒有明確的選擇方法。但我可以告訴你一個選擇原則：如果多程序和多執行緒都能夠滿足要求，那麼選擇你最熟悉、最拿手的那個。

需要提醒的是：雖然我給了這麼多的選擇原則，但實際應用中基本上都是“程序+執行緒”的結合方式，千萬不要真的陷入一種非此即彼的誤區。

1、程序與執行緒

程序是程式執行時的一個例項，即它是程式已經執行到課中程度的資料結構的彙集。從核心的觀點看，程序的目的就是擔當分配系統資源（CPU時間、記憶體等）的基本單位。

執行緒是程序的一個執行流，是CPU排程和分派的基本單位，它是比程序更小的能獨立執行的基本單位。一個程序由幾個執行緒組成（擁有很多相對獨立的執行流的使用者程式共享應用程式的大部分資料結構），執行緒與同屬一個程序的其他的執行緒共享程序所擁有的全部資源。

"程序——資源分配的最小單位，執行緒——程式執行的最小單位"

程序有獨立的地址空間，一個程序崩潰後，在保護模式下不會對其它程序產生影響，而執行緒只是一個程序中的不同執行路徑。執行緒有自己的堆疊和區域性變數，但執行緒沒有單獨的地址空間，一個執行緒死掉就等於整個程序死掉，所以多程序的程式要比多執行緒的程式健壯，但在程序切換時，耗費資源較大，效率要差一些。但對於一些要求同時進行並且又要共享某些變數的併發操作，只能用執行緒，不能用程序。

總的來說就是：程序有獨立的地址空間，執行緒沒有單獨的地址空間（同一程序內的執行緒共享程序的地址空間）。（下面的內容摘自Linux下的多執行緒程式設計）

使用多執行緒的理由之一是和程序相比，它是一種非常"節儉"的多工操作方式。我們知道，在Linux系統下，啟動一個新的程序必須分配給它獨立的地址空間，建立眾多的資料表來維護它的程式碼段、堆疊段和資料段，這是一種"昂貴"的多工工作方式。而運行於一個程序中的多個執行緒，它們彼此之間使用相同的地址空間，共享大部分資料，啟動一個執行緒所花費的空間遠遠小於啟動一個程序所花費的空間，而且，執行緒間彼此切換所需的時間也遠遠小於程序間切換所需要的時間。據統計，總的說來，一個程序的開銷大約是一個執行緒開銷的30倍左右，當然，在具體的系統上，這個資料可能會有較大的區別。

使用多執行緒的理由之二是執行緒間方便的通訊機制。對不同程序來說，它們具有獨立的資料空間，要進行資料的傳遞只能通過通訊的方式進行，這種方式不僅費時，而且很不方便。執行緒則不然，由於同一程序下的執行緒之間共享資料空間，所以一個執行緒的資料可以直接為其它執行緒所用，這不僅快捷，而且方便。當然，資料的共享也帶來其他一些問題，有的變數不能同時被兩個執行緒所修改，有的子程式中宣告為static的資料更有可能給多執行緒程式帶來災難性的打擊，這些正是編寫多執行緒程式時最需要注意的地方。

除了以上所說的優點外，不和程序比較，多執行緒程式作為一種多工、併發的工作方式，當然有以下的優點：

• 提高應用程式響應。這對圖形介面的程式尤其有意義，當一個操作耗時很長時，整個系統都會等待這個操作，此時程式不會響應鍵盤、滑鼠、選單的操作，而使用多執行緒技術，將耗時長的操作（time consuming）置於一個新的執行緒，可以避免這種尷尬的情況。
• 使多CPU系統更加有效。作業系統會保證當執行緒數不大於CPU數目時，不同的執行緒運行於不同的CPU上。
• 改善程式結構。一個既長又複雜的程序可以考慮分為多個執行緒，成為幾個獨立或半獨立的執行部分，這樣的程式會利於理解和修改。

在Unix上程式設計採用多執行緒還是多程序的爭執由來已久，這種爭執最常見到在B/S通訊中服務端併發技術 的選型上，比如WEB伺服器技術中，Apache是採用多程序的（perfork模式，每客戶連線對應一個程序，每程序中只存在唯一一個執行線 程），Java的Web容器Tomcat、Websphere等都是多執行緒的（每客戶連線對應一個執行緒，所有執行緒都在一個程序中）。

從Unix發展歷史看，伴隨著Unix的誕生多程序就出現了，而多執行緒很晚才被系統支援，例如Linux直到核心2.6，才支援符合Posix規範的NPTL執行緒庫。程序和執行緒的特點，也就是各自的優缺點如下：

程序優點：程式設計、除錯簡單，可靠性較高。
程序缺點：建立、銷燬、切換速度慢，記憶體、資源佔用大。
執行緒優點：建立、銷燬、切換速度快，記憶體、資源佔用小。
執行緒缺點：程式設計、除錯複雜，可靠性較差。

上面的對比可以歸結為一句話：“執行緒快而程序可靠性高”。執行緒有個別名叫“輕量級程序”，在有的書籍資料上介紹執行緒可以十倍、百倍的效率快於程序； 而程序之間不共享資料，沒有鎖問題，結構簡單，一個程序崩潰不像執行緒那樣影響全域性，因此比較可靠。我相信這個觀點可以被大部分人所接受，因為和我們所接受的知識概念是相符的。

在寫這篇文章前，我也屬於這“大部分人”，這兩年在用C語言編寫的幾個C/S通訊程式中，因時間緊總是採用多程序併發技術，而且是比較簡單的現場為 每客戶fork()一個程序，當時總是擔心併發量增大時負荷能否承受，盤算著等時間充裕了將它改為多執行緒形式，或者改為預先建立程序的形式，直到最近在網 上看到了一篇論文《Linux系統下多執行緒與多程序效能分析》作者“周麗 焦程波 蘭巨龍”，才認真思考這個問題，我自己也做了實驗，結論和論文作者的相似，但對大部分人可以說是顛覆性的。

下面是得出結論的實驗步驟和過程，結論究竟是怎樣的？ 感興趣就一起看看吧。

實驗程式碼使用周麗論文中的程式碼樣例，我做了少量修改，值得注意的是這樣的區別：

論文實驗和我的實驗時間不同，論文所處的年代linux核心是2.4，我的實驗linux核心是2.6，2.6使用的執行緒庫是NPTL，2.4使用的是老的Linux執行緒庫（用程序模擬執行緒的那個LinuxThread）。

論文實驗和我用的機器不同，論文描述了使用的環境：單cpu 機器基本配置為:celeron 2.0 GZ, 256M, Linux 9.2,核心 2.4.8。我的環境是：雙核 Intel(R) Xeon(R) CPU 5130  @ 2.00GHz（做實驗時，禁掉了一核），512MG記憶體，Red Hat Enterprise Linux ES release 4 (Nahant Update 4)，核心2.6.9-42。

程序實驗程式碼（fork.c）：

1. #include <stdlib.h>
   
2. #include <stdio.h>
   
3. #include <signal.h>
   
4. #define P_NUMBER 255 //併發程序數量
   
5. #define COUNT 5 //每次程序列印字串數
   
6. #define TEST_LOGFILE "logFile.log"
   
7. FILE *logFile=NULL;
   
8. char *s="hello linux\0";
   
9. int main()
   
10. {
    
11.     int i=0,j=0;
    
12.     logFile=fopen(TEST_LOGFILE,"a+");//開啟日誌檔案
    
13.     for(i=0;i<P_NUMBER;i++)
    
14.     {
    
15.         if(fork()==0)//建立子程序，if(fork()==0){}這段程式碼是子程序執行區間
    
16.         {
    
17.             for(j=0;j<COUNT;j++)
    
18.             {
    
19.                 printf("[%d]%s\n",j,s);//向控制檯輸出
20.                 /*當你頻繁讀寫檔案的時候，Linux核心為了提高讀寫效能與速度，會將檔案在記憶體中進行快取，這部分記憶體就是Cache Memory(快取記憶體)。可能導致測試結果不準，所以在此註釋*/
    
21.                 //fprintf(logFile,"[%d]%s\n",j,s);//向日志文件輸出，
    
22.             }
    
23.             exit(0);//子程序結束
    
24.         }
    
25.     }
    
26.     for(i=0;i<P_NUMBER;i++)//回收子程序
    
27.     {
    
28.         wait(0);
    
29.     }
    
30.     printf("Okay\n");
    
31.     return 0;
    
32. }

程序實驗程式碼（thread.c）：

1. #include <pthread.h>
   
2. #include <unistd.h>
   
3. #include <stdlib.h>
   
4. #include <stdio.h>
   
5. #define P_NUMBER 255//併發執行緒數量
   
6. #define COUNT 5 //每執行緒列印字串數
   
7. #define TEST_LOG "logFile.log"
   
8. FILE *logFile=NULL;
   
9. char *s="hello linux\0";
   
10. print_hello_linux()//執行緒執行的函式
    
11. {
    
12.     int i=0;
    
13.     for(i=0;i<COUNT;i++)
    
14.     {
    
15.         printf("[%d]%s\n",i,s);//想控制檯輸出
16.         /*當你頻繁讀寫檔案的時候，Linux核心為了提高讀寫效能與速度，會將檔案在記憶體中進行快取，這部分記憶體就是Cache Memory(快取記憶體)。可能導致測試結果不準，所以在此註釋*/
17.         //fprintf(logFile,"[%d]%s\n",i,s);//向日志文件輸出
    
18.     }
    
19.     pthread_exit(0);//執行緒結束
    
20. }
    
21. int main()
    
22. {
    
23.     int i=0;
    
24.     pthread_t pid[P_NUMBER];//執行緒陣列
    
25.     logFile=fopen(TEST_LOG,"a+");//開啟日誌檔案
    
26.     for(i=0;i<P_NUMBER;i++)
    
27.         pthread_create(&pid[i],NULL,(void *)print_hello_linux,NULL);//建立執行緒
    
28.     for(i=0;i<P_NUMBER;i++)
    
29.         pthread_join(pid[i],NULL);//回收執行緒
    
30.     printf("Okay\n");
    
31.     return 0;
    
32. }

兩段程式做的事情是一樣的，都是建立“若干”個程序/執行緒，每個創建出的程序/執行緒列印“若干”條“hello linux”字串到控制檯和日誌檔案，兩個“若干”由兩個巨集 P_NUMBER和COUNT分別定義，程式編譯指令如下：

gcc -o fork fork.c
gcc -lpthread -o thread thread.c

實驗通過time指令執行兩個程式，抄錄time輸出的掛鐘時間（real時間）：

time ./fork
time ./thread

每批次的實驗通過改動巨集 P_NUMBER和COUNT來調整程序/執行緒數量和列印次數，每批次測試五輪，得到的結果如下：

一、重複周麗論文實驗步驟

(注：本文平均值演算法採用的是去掉一個最大值去掉一個最小值，然後平均)

單核（雙核機器禁掉一核），程序/執行緒數：255，列印次數5
第1次	第2次	第3次	第4次	第5次	平均
多程序	0m0.070s	0m0.071s	0m0.071s	0m0.070s	0m0.070s	0m0.070s
多執行緒	0m0.049s	0m0.049s	0m0.049s	0m0.049s	0m0.049s	0m0.049s

單核（雙核機器禁掉一核），程序/執行緒數：255，列印次數10
第1次	第2次	第3次	第4次	第5次	平均
多程序	0m0.112s	0m0.101s	0m0.100s	0m0.085s	0m0.121s	0m0.104s
多執行緒	0m0.097s	0m0.089s	0m0.090s	0m0.104s	0m0.080s	0m0.092s

單核（雙核機器禁掉一核），程序/執行緒數：255，列印次數50
第1次	第2次	第3次	第4次	第5次	平均
多程序	0m0.459s	0m0.531s	0m0.499s	0m0.499s	0m0.524s	0m0.507s
多執行緒	0m0.387s	0m0.456s	0m0.435s	0m0.423s	0m0.408s	0m0.422s

單核（雙核機器禁掉一核），程序/執行緒數：255，列印次數100
第1次	第2次	第3次	第4次	第5次	平均
多程序	0m1.141s	0m0.992s	0m1.134s	0m1.027s	0m0.965s	0m1.051s
多執行緒	0m0.925s	0m0.899s	0m0.961s	0m0.934s	0m0.853s	0m0.919s

單核（雙核機器禁掉一核），程序/執行緒數：255，列印次數500
第1次	第2次	第3次	第4次	第5次	平均
多程序	0m5.221s	0m5.258s	0m5.706s	0m5.288s	0m5.455s	0m5.334s
多執行緒	0m4.689s	0m4.578s	0m4.670s	0m4.566s	0m4.722s	0m4.646s

單核（雙核機器禁掉一核），程序/執行緒數：255，列印次數1000
第1次	第2次	第3次	第4次	第5次	平均
多程序	0m12.680s	0m16.555s	0m11.158s	0m10.922s	0m11.206s	0m11.681s
多執行緒	0m12.993s	0m13.087s	0m13.082s	0m13.485s	0m13.053s	0m13.074s

單核（雙核機器禁掉一核），程序/執行緒數：255，列印次數5000
第1次	第2次	第3次	第4次	第5次	平均
多程序	1m27.348s	1m5.569s	0m57.275s	1m5.029s	1m15.174s	1m8.591s
多執行緒	1m25.813s	1m29.299s	1m23.842s	1m18.914s	1m34.872s	1m26.318s

單核（雙核機器禁掉一核），程序/執行緒數：255，列印次數10000
第1次	第2次	第3次	第4次	第5次	平均
多程序	2m8.336s	2m22.999s	2m11.046s	2m30.040s	2m5.752s	2m14.137s
多執行緒	2m46.666s	2m44.757s	2m34.528s	2m15.018s	2m41.436s	2m40.240s

本輪實驗是為了和周麗論文作對比，因此將程序/執行緒數量限制在255個，論文也是測試了255個程序/執行緒分別進行5次，10 次,50 次,100 次,500 次……10000 次列印的用時，論文得出的結果是：任務量較大時,多程序比多執行緒效率高;而完成的任務量較小時,多執行緒比多程序要快，重複列印 600 次時,多程序與多執行緒所耗費的時間相同。

雖然我的實驗直到1000列印次數時，多程序才開始領先，但考慮到使用的是NPTL執行緒庫的緣故，從而可以證實了論文的觀點。從我的實驗資料看，多執行緒和多程序兩組資料非常接近，考慮到資料的提取具有瞬間性，因此可以認為他們的速度是相同的。

是不是可以得出這樣的結論：多執行緒建立、銷燬速度快，而多執行緒切換速度快，這個結論我們會在第二個試驗中繼續試圖驗證

當前的網路環境中，我們更看中高併發、高負荷下的效能，縱觀前面的實驗步驟，最長的實驗週期不過2分鐘多一點，因此下面的實驗將向兩個方向延伸，第一，增加併發數量，第二，增加每程序/執行緒的工作強度。

二、增加併發數量的實驗

下面的實驗列印次數不變，而程序/執行緒數量逐漸增加。在實驗過程中多執行緒程式在後四組（執行緒數350，500，800,1000）的測試中都出現了“段錯誤”，出現錯誤的原因和多執行緒預分配執行緒棧有關。

實驗中的計算機CPU是32位，定址最大範圍是4GB（2的32次方），Linux是按照3GB/1GB的方式來分配記憶體，其中1GB屬於所有程序共享的核心空間，3GB屬於使用者空間（程序虛擬記憶體空間）。Linux2.6的預設執行緒棧大小是8M（通過ulimit -a檢視），對於多執行緒，在建立執行緒的時候系統會為每一個執行緒預分配執行緒棧地址空間，也就是8M的虛擬記憶體空間。執行緒數量太多時，執行緒棧累計的大小將超過程序虛擬記憶體空間大小（計算時需要排除程式文字、資料、共享庫等佔用的空間），這就是實驗中出現的“段錯誤”的原因。

Linux2.6的預設執行緒棧大小可以通過 ulimit -s 命令檢視或修改，我們可以計算出執行緒數的最大上線: (1024*1024*1024*3) / (1024*1024*8) = 384，實際數字應該略小與384，因為還要計算程式文字、資料、共享庫等佔用的空間。在當今的稍顯繁忙的WEB伺服器上，突破384的併發訪問並不是稀 罕的事情，要繼續下面的實驗需要將預設執行緒棧的大小減小，但這樣做有一定的風險，比如執行緒中的函式分配了大量的自動變數或者函式涉及很深的棧幀（典型的是 遞迴呼叫），執行緒棧就可能不夠用了。可以配合使用POSIX.1規定的兩個執行緒屬性guardsize和stackaddr來解決執行緒棧溢位問 題，guardsize控制著執行緒棧末尾之後的一篇記憶體區域，一旦執行緒棧在使用中溢位併到達了這片記憶體，程式可以捕獲系統核心發出的告警訊號，然後使用 malloc獲取另外的記憶體，並通過stackaddr改變執行緒棧的位置，以獲得額外的棧空間，這個動態擴充套件棧空間辦法需要手工程式設計，而且非常麻煩。

有兩種方法可以改變執行緒棧的大小，使用 ulimit -s 命令改變系統預設執行緒棧的大小，或者在程式碼中建立執行緒時通過pthread_attr_setstacksize函式改變棧尺寸，在實驗中使用的是第一種，在程式執行前先執行ulimit指令將預設執行緒棧大小改為1M：

ulimit -s 1024
time ./thread

單核（雙核機器禁掉一核），程序/執行緒數：100 ，列印次數1000
第1次	第2次	第3次	第4次	第5次	平均
多程序	0m3.834s	0m3.759s	0m4.376s	0m3.936s	0m3.851s	0m3.874
多執行緒	0m3.646s	0m4.498s	0m4.219s	0m3.893s	0m3.943s	0m4.018

單核（雙核機器禁掉一核），程序/執行緒數：255 ，列印次數1000
第1次	第2次	第3次	第4次	第5次	平均
多程序	0m9.731s	0m9.833s	0m10.046s	0m9.830s	0m9.866s	0m9.843s
多執行緒	0m9.961s	0m9.699s	0m9.958s	0m10.111s	0m9.686s	0m9.873s

單核（雙核機器禁掉一核），程序/執行緒數：350  ，列印次數1000
第1次	第2次	第3次	第4次	第5次	平均
多程序	0m13.773s	0m13.500s	0m13.519s	0m13.474s	0m13.351s	0m13.498
多執行緒	0m12.754s	0m13.251s	0m12.813s	0m16.861s	0m12.764s	0m12.943

單核（雙核機器禁掉一核），程序/執行緒數： 500 ，列印次數1000
第1次	第2次	第3次	第4次	第5次	平均
多程序	0m23.762s	0m22.151s	0m23.926s	0m21.327s	0m21.429s	0m22.413
多執行緒	0m20.603s	0m20.291s	0m21.654s	0m20.684s	0m20.671s	0m20.653

單核（雙核機器禁掉一核），程序/執行緒數：800  ，列印次數1000
第1次	第2次	第3次	第4次	第5次	平均
多程序	0m33.616s	0m31.757s	0m31.759s	0m32.232s	0m32.498s	0m32.163
多執行緒	0m32.050s	0m32.787s	0m33.055s	0m32.902s	0m32.235s	0m32.641

單核（雙核機器禁掉一核），程序/執行緒數： 1000 ，列印次數1000
第1次	第2次	第3次	第4次	第5次	平均
多程序	0m40.301s	0m41.083s	0m41.634s	0m40.247s	0m40.717s	0m40.700
多執行緒	0m41.633s	0m41.118s	0m42.700s	0m42.134s	0m41.170s	0m41.646

【實驗結論】 

相關推薦