linux線程池實現原理

A. 線程池哪個語言用的多

Java語言
Java語言對於多線程的支持十分豐富，JDK本身提供了很多性能優良的庫，包括ThreadPoolExecutor和ScheleThreadPoolExecutor等。
使用線程池原因：因為線程的創建、和清理都是需要耗費系統資源的。我們知道linux中線程實際上是由輕量級進程實現的，相對於純理論上的線程這個開銷還是有的。含洞假設某個線程的創建、運行和銷毀的時間分別為T1、T2、T3，當T1+T3的時旁宴間相對於T2不可忽略時，線程池的就有必要引入了，尤其是處理數百萬級的高並發處理時。線程池提升了多線程程序的性能，因為線程池裡面的線程都是現成的而且能夠重復使用，我們不需要臨時創建大量線程，然後在任務結束時又銷毀大量線程。一個理想的線程池能夠談啟枯合理地動態調節池內線程數量，既不會因為線程過少而導致大量任務堆積，也不會因為線程過多了而增加額外的系統開銷。

B. 麻煩解釋一下linux下進程和線程有什麼區別和聯系，linux下多線程和多進程通信的實現方法，請通俗解釋

兄弟看到你這么高的分我就找了些資料：也算是對昨天學的知識總結一下吧
一、先說概念不管是windows還是linux下的進程和線程概念都是一樣的，只是管理進程和線程的方式不一樣，這個是前提，到時候你可別問我windows下進程和線程啊。這個涉及到操作系統原理。下面給你解答。
說道進程不得不提作業這個名詞 ，我想兄弟你電腦里不會有一個程序吧對不？當你的系統啟動完畢後你看看你的任務管理器里是不是有很多進程呢？那麼多程序是怎麼調如內存呢？能理解嗎？這里要明白程序和進程的關系，程序是你磁碟上的一個文件，當你需要它時進入內存後才成為進程，好比QQ在磁碟上就是一個文件而已，只有進入了內存才成為進程，進程是活動的。QQ要掃描你文件啊，記錄你聊天記錄啊，偷偷上傳個啥東西什麼的你也不知道對不，他是活動的。這個能明白嗎？
再看作業，這個作業可不是你寫作業的那個作業啊。系統一看好傢伙你個QQ那麼大的傢伙你想一下子進入內存啊？沒門！慢慢來嘛，系統就把QQ程序分為好幾塊，這幾塊不能亂分的，要符合自然結構就是循環啦選擇啦這樣的結構，你把人家循環結構咔嚓截斷了，怎麼讓人家QQ運行啊？這就是作業要一塊一塊的進入內存，同時要為作業產生JCB（JOB CONTROL BLOCK)作業控制塊，你進入內存不能亂跑啊，要聽系統的話，你要是進入系統自己的內存。框一下，內存不能讀寫 對話框就出來了，嚴重點直接藍臉給你！你懂得。這是window下的，linux下直接給你報錯！沒事了就！所一系統通過jcb控制進程。JCB包含了進程號優先順序好多內容，你打開你的windows任務管理器看看進程是不是有好多屬性啊？那就是PCB（PRCESS，CONTROL BLOCK）同理作業也包含那些內容只是多少而已。下面寫出進程特點：
1、進程是分配計算機資源最小的單位。你想啊人是要用程序幹活的吧？你把程序調入內存成了就成了進程，所以說進程是分配資源的最小單位。你在linux下打開終端輸入top命令看是不是有好多進程？
2、進程有操作系統為作業產生。有「父進程」產生「子進程」之間是父子關系，並可以繼續向下產生「子進程」。還拿QQ來說，你雙擊QQ.exe。QQ啟動了輸入賬號密碼打開主界面了。這時候你要聊天，QQ進程趕緊產生個「兒子」說 「兒子你去陪主人聊天去吧。這樣子進程產生了。突然你想看美女要傳照片這時候那個」兒子「有」生「了一個」兒子「說」兒子「你去傳照片。那個「兒子領到任務去傳照片了。這時你想關了QQ，QQ提示你說」你還有個「兒子」和「孫子」還在幹活呢你真要結束嗎？你蒽了確定。QQ對他「兒子」（你聊天窗口）說：」兒子啊對不起了，主人要關閉我你也不能活啊「咔嚓一下」兒子「死了，兒子死之前對他兒子說：「兒子啊你爺爺不讓我活了，你也別活了咔嚓孫子也死了。最後世界安靜了。這就是進程的父子關系。能明白嗎？記住：進程之活動在內存中。不能使用CPU，只管分配資源。
再說線程：線程也產生在內存中並且在內存中存在相當長的時間，但它的活動區域主要在CPU中，並且運行和滅亡都存在於CPU中，可以這么說，線程是程序中能被系統調度進入CPU中最小程序單位，它能直接使用進程分配的CPU的資源。
還拿QQ來說當你要傳文件時QQ總要判斷一下文件的擴展名吧，ok這時那個」兒子「趕緊對它爸爸說我需要一個線程判斷擴展名QQ趕緊對一個管這個的線程說：」快點去CPU里計算下那個擴展名是什麼然後向主人報告計算完了就「死了」消亡了，但是它的線程還在內存中！還等著你下一次傳文件然後計算然後消亡！
線程之間是相互獨立的。一個在CPU，一個在內存里還能有關系嗎對不？CPU在每一個瞬間只能進入一個線程，當線程進入CPU時立即產生一個新的線程，新線程仍停留在內存中，就好比上面那個傳文件還會等著你再傳文件再計算擴展名。
線程相對線程是獨立的，但它在內存中並不是獨立的，這就好比你不開QQ能用QQ傳輸文件嗎？它只存在與進程分配的資源中，也就是說計算擴展名這個線程只能停留在QQ這個進程中，不能跑到別的進程里！！相當於程序產生了新的進程和線程，進程向CPU申請資源，再有線程來使用，他們都是為程序服務的只是分工不同！
因為你沒提問linux下是怎麼管理進程和線程的所以我就不回答了，這個問題我建議你還是看看《笨兔兔的故事》裡面講到了linux是怎麼管理進程和線程的。挺幽默的比我說得還好。
你第二個問題說實話我回答不了你！我想你現在連進程和線程還沒理解第二個你更理解不了了你說對不？我猜的其實你用C/C++不管是在windows下編程還是在Linux下編程思想都是一樣的對吧，如果你理解了在windows下線程間通信，在linux更沒問題了！
參考資料：黑客手冊2009合訂本非安全第一二季244頁，245頁，328頁，329頁，398頁，399頁
淺談操作系統原理 （一 二三）
ubuntu中文論壇 笨兔兔的故事
http://forum.ubuntu.org.cn/viewtopic.php?f=120&t=267518
希望我的回答你能理解

C. 如何看懂《Linux多線程服務端編程

一：進程和線程
每個進程有自己獨立的地址空間。「在同一個進程」還是「不在同一個進程」是系統功能劃分的重要決策點。《Erlang程序設計》[ERL]把進程比喻為人：
每個人有自己的記憶（內存），人與人通過談話（消息傳遞）來交流，談話既可以是面談（同一台伺服器），也可以在電話里談（不同的伺服器，有網路通信）。面談和電話談的區別在於，面談可以立即知道對方是否死了（crash,SIGCHLD），而電話談只能通過周期性的心跳來判斷對方是否還活著。
有了這些比喻，設計分布式系統時可以採取「角色扮演」，團隊里的幾個人各自扮演一個進程，人的角色由進程的代碼決定（管登錄的、管消息分發的、管買賣的等等）。每個人有自己的記憶，但不知道別人的記憶，要想知道別人的看法，只能通過交談（暫不考慮共享內存這種IPC）。然後就可以思考：
·容錯：萬一有人突然死了
·擴容：新人中途加進來
·負載均衡：把甲的活兒挪給乙做
·退休：甲要修復bug，先別派新任務，等他做完手上的事情就把他重啟
等等各種場景，十分便利。

線程的特點是共享地址空間，從而可以高效地共享數據。一台機器上的多個進程能高效地共享代碼段(操作系統可以映射為同樣的物理內存)，但不能共享數據。如果多個進程大量共享內存，等於是把多進程程序當成多線程來寫，掩耳盜鈴。
「多線程」的價值，我認為是為了更好地發揮多核處理器(multi-cores)的效能。在單核時代，多線程沒有多大價值（個人想法：如果要完成的任務是CPU密集型的，那多線程沒有優勢，甚至因為線程切換的開銷，多線程反而更慢；如果要完成的任務既有CPU計算，又有磁碟或網路IO，則使用多線程的好處是，當某個線程因為IO而阻塞時，OS可以調度其他線程執行，雖然效率確實要比任務的順序執行效率要高，然而，這種類型的任務，可以通過單線程的」non-blocking IO+IO multiplexing」的模型（事件驅動）來提高效率，採用多線程的方式，帶來的可能僅僅是編程上的簡單而已）。Alan Cox說過：」A computer is a state machine.Threads are for people who can』t program state machines.」（計算機是一台狀態機。線程是給那些不能編寫狀態機程序的人准備的）如果只有一塊CPU、一個執行單元，那麼確實如Alan Cox所說，按狀態機的思路去寫程序是最高效的。

二：單線程伺服器的常用編程模型
據我了解，在高性能的網路程序中，使用得最為廣泛的恐怕要數」non-blocking IO + IO multiplexing」這種模型，即Reactor模式。
在」non-blocking IO + IO multiplexing」這種模型中，程序的基本結構是一個事件循環（event loop），以事件驅動（event-driven）和事件回調的方式實現業務邏輯：
[cpp] view plain
//代碼僅為示意，沒有完整考慮各種情況
while(!done)
{
int timeout_ms = max(1000, getNextTimedCallback());
int retval = poll(fds, nfds, timeout_ms);
if (retval<0){
處理錯誤，回調用戶的error handler
}else{
處理到期的timers,回調用戶的timer handler
if(retval>0){
處理IO事件，回調用戶的IO event handler
}
}
}

這里select(2)/poll(2)有伸縮性方面的不足（描述符過多時，效率較低），Linux下可替換為epoll(4)，其他操作系統也有對應的高性能替代品。
Reactor模型的優點很明顯，編程不難，效率也不錯。不僅可以用於讀寫socket，連接的建立(connect(2)/accept(2))，甚至DNS解析都可以用非阻塞方式進行，以提高並發度和吞吐量(throughput)，對於IO密集的應用是個不錯的選擇。lighttpd就是這樣，它內部的fdevent結構十分精妙，值得學習。
基於事件驅動的編程模型也有其本質的缺點，它要求事件回調函數必須是非阻塞的。對於涉及網路IO的請求響應式協議，它容易割裂業務邏輯，使其散布於多個回調函數之中，相對不容易理解和維護。

三：多線程伺服器的常用編程模型
大概有這么幾種：
a：每個請求創建一個線程，使用阻塞式IO操作。在Java 1.4引人NIO之前，這是Java網路編程的推薦做法。可惜伸縮性不佳（請求太多時，操作系統創建不了這許多線程）。
b：使用線程池，同樣使用阻塞式IO操作。與第1種相比，這是提高性能的措施。
c：使用non-blocking IO + IO multiplexing。即Java NIO的方式。
d：Leader/Follower等高級模式。
在默認情況下，我會使用第3種，即non-blocking IO + one loop per thread模式來編寫多線程C++網路服務程序。

1：one loop per thread
此種模型下，程序里的每個IO線程有一個event loop，用於處理讀寫和定時事件（無論周期性的還是單次的）。代碼框架跟「單線程伺服器的常用編程模型」一節中的一樣。
libev的作者說：
One loop per thread is usually a good model. Doing this is almost never wrong, some times a better-performance model exists, but it is always a good start.

這種方式的好處是：
a：線程數目基本固定，可以在程序啟動的時候設置，不會頻繁創建與銷毀。
b：可以很方便地在線程間調配負載。
c：IO事件發生的線程是固定的，同一個TCP連接不必考慮事件並發。

Event loop代表了線程的主循環，需要讓哪個線程幹活，就把timer或IO channel（如TCP連接）注冊到哪個線程的loop里即可：對實時性有要求的connection可以單獨用一個線程；數據量大的connection可以獨佔一個線程，並把數據處理任務分攤到另幾個計算線程中（用線程池）；其他次要的輔助性connections可以共享一個線程。
比如，在dbproxy中，一個線程用於專門處理客戶端發來的管理命令；一個線程用於處理客戶端發來的MySQL命令，而與後端資料庫通信執行該命令時，是將該任務分配給所有事件線程處理的。

對於non-trivial（有一定規模）的服務端程序，一般會採用non-blocking IO + IO multiplexing，每個connection/acceptor都會注冊到某個event loop上，程序里有多個event loop，每個線程至多有一個event loop。
多線程程序對event loop提出了更高的要求，那就是「線程安全」。要允許一個線程往別的線程的loop里塞東西，這個loop必須得是線程安全的。
在dbproxy中，線程向其他線程分發任務，是通過管道和隊列實現的。比如主線程accept到連接後，將表示該連接的結構放入隊列，並向管道中寫入一個位元組。計算線程在自己的event loop中注冊管道的讀事件，一旦有數據可讀，就嘗試從隊列中取任務。

2：線程池
不過，對於沒有IO而光有計算任務的線程，使用event loop有點浪費。可以使用一種補充方案，即用blocking queue實現的任務隊列：
[cpp] view plain
typedef boost::functionFunctor;
BlockingQueue taskQueue; //線程安全的全局阻塞隊列

//計算線程
void workerThread()
{
while (running) //running變數是個全局標志
{
Functor task = taskQueue.take(); //this blocks
task(); //在產品代碼中需要考慮異常處理
}
}

// 創建容量（並發數）為N的線程池
int N = num_of_computing_threads;
for (int i = 0; i < N; ++i)
{
create_thread(&workerThread); //啟動線程
}

//向任務隊列中追加任務
Foo foo; //Foo有calc()成員函數
boost::function task = boost::bind(&Foo::calc，&foo);
taskQueue.post(task);

除了任務隊列，還可以用BlockingQueue實現數據的生產者消費者隊列，即T是數據類型而非函數對象，queue的消費者從中拿到數據進行處理。其實本質上是一樣的。

3：總結
總結而言，我推薦的C++多線程服務端編程模式為：one (event) loop per thread + thread pool：
event loop用作IO multiplexing，配合non-blockingIO和定時器；
thread pool用來做計算，具體可以是任務隊列或生產者消費者隊列。

以這種方式寫伺服器程序，需要一個優質的基於Reactor模式的網路庫來支撐，muo正是這樣的網路庫。比如dbproxy使用的是libevent。
程序里具體用幾個loop、線程池的大小等參數需要根據應用來設定，基本的原則是「阻抗匹配」（解釋見下），使得CPU和IO都能高效地運作。所謂阻抗匹配原則：
如果池中線程在執行任務時，密集計算所佔的時間比重為 P (0 < P <= 1)，而系統一共有 C 個 CPU，為了讓這 C 個 CPU 跑滿而又不過載，線程池大小的經驗公式 T = C/P。（T 是個 hint，考慮到 P 值的估計不是很准確，T 的最佳值可以上下浮動 50%）
以後我再講這個經驗公式是怎麼來的，先驗證邊界條件的正確性。
假設 C = 8，P = 1.0，線程池的任務完全是密集計算，那麼T = 8。只要 8 個活動線程就能讓 8 個 CPU 飽和，再多也沒用，因為 CPU 資源已經耗光了。
假設 C = 8，P = 0.5，線程池的任務有一半是計算，有一半等在 IO 上，那麼T = 16。考慮操作系統能靈活合理地調度 sleeping/writing/running 線程，那麼大概 16 個「50%繁忙的線程」能讓 8 個 CPU 忙個不停。啟動更多的線程並不能提高吞吐量，反而因為增加上下文切換的開銷而降低性能。
如果 P < 0.2，這個公式就不適用了，T 可以取一個固定值，比如 5*C。

另外，公式里的 C 不一定是 CPU 總數，可以是「分配給這項任務的 CPU 數目」，比如在 8 核機器上分出 4 個核來做一項任務，那麼 C=4。

四：進程間通信只用TCP
Linux下進程間通信的方式有：匿名管道(pipe)、具名管道(FIFO)、POSIX消息隊列、共享內存、信號(signals)，以及Socket。同步原語有互斥器(mutex)、條件變數(condition variable)、讀寫鎖(reader-writer lock)、文件鎖(record locking)、信號量(semaphore)等等。

進程間通信我首選Sockets（主要指TCP，我沒有用過UDP，也不考慮Unix domain協議）。其好處在於：
可以跨主機，具有伸縮性。反正都是多進程了，如果一台機器的處理能力不夠，很自然地就能用多台機器來處理。把進程分散到同一區域網的多台機器上，程序改改host:port配置就能繼續用；
TCP sockets和pipe都是操作文件描述符，用來收發位元組流，都可以read/write/fcntl/select/poll等。不同的是，TCP是雙向的，Linux的pipe是單向的，進程間雙向通信還得開兩個文件描述符，不方便；而且進程要有父子關系才能用pipe，這些都限制了pipe的使用；
TCP port由一個進程獨占，且進程退出時操作系統會自動回收文件描述符。因此即使程序意外退出，也不會給系統留下垃圾，程序重啟之後能比較容易地恢復，而不需要重啟操作系統（用跨進程的mutex就有這個風險）；而且，port是獨占的，可以防止程序重復啟動，後面那個進程搶不到port，自然就沒法初始化了，避免造成意料之外的結果；
與其他IPC相比，TCP協議的一個天生的好處是「可記錄、可重現」。tcpmp和Wireshark是解決兩個進程間協議和狀態爭端的好幫手，也是性能（吞吐量、延遲）分析的利器。我們可以藉此編寫分布式程序的自動化回歸測試。也可以用tcp之類的工具進行壓力測試。TCP還能跨語言，服務端和客戶端不必使用同一種語言。

分布式系統的軟體設計和功能劃分一般應該以「進程」為單位。從宏觀上看，一個分布式系統是由運行在多台機器上的多個進程組成的，進程之間採用TCP長連接通信。
使用TCP長連接的好處有兩點：一是容易定位分布式系統中的服務之間的依賴關系。只要在機器上運行netstat -tpna|grep 就能立刻列出用到某服務的客戶端地址（Foreign Address列），然後在客戶端的機器上用netstat或lsof命令找出是哪個進程發起的連接。TCP短連接和UDP則不具備這一特性。二是通過接收和發送隊列的長度也較容易定位網路或程序故障。在正常運行的時候，netstat列印的Recv-Q和Send-Q都應該接近0，或者在0附近擺動。如果Recv-Q保持不變或持續增加，則通常意味著服務進程的處理速度變慢，可能發生了死鎖或阻塞。如果Send-Q保持不變或持續增加，有可能是對方伺服器太忙、來不及處理，也有可能是網路中間某個路由器或交換機故障造成丟包，甚至對方伺服器掉線，這些因素都可能表現為數據發送不出去。通過持續監控Recv-Q和Send-Q就能及早預警性能或可用性故障。以下是服務端線程阻塞造成Recv-Q和客戶端Send-Q激增的例子：
[cpp] view plain
$netstat -tn
Proto Recv-Q Send-Q Local Address Foreign
tcp 78393 0 10.0.0.10:2000 10.0.0.10:39748 #服務端連接
tcp 0 132608 10.0.0.10:39748 10.0.0.10:2000 #客戶端連接
tcp 0 52 10.0.0.10:22 10.0.0.4:55572

五：多線程伺服器的適用場合
如果要在一台多核機器上提供一種服務或執行一個任務，可用的模式有：
a：運行一個單線程的進程；
b：運行一個多線程的進程；
c：運行多個單線程的進程；
d：運行多個多線程的進程；

考慮這樣的場景：如果使用速率為50MB/s的數據壓縮庫，進程創建銷毀的開銷是800微秒，線程創建銷毀的開銷是50微秒。如何執行壓縮任務？
如果要偶爾壓縮1GB的文本文件，預計運行時間是20s，那麼起一個進程去做是合理的，因為進程啟動和銷毀的開銷遠遠小於實際任務的耗時。
如果要經常壓縮500kB的文本數據，預計運行時間是10ms，那麼每次都起進程 似乎有點浪費了，可以每次單獨起一個線程去做。
如果要頻繁壓縮10kB的文本數據，預計運行時間是200微秒，那麼每次起線程似 乎也很浪費，不如直接在當前線程搞定。也可以用一個線程池，每次把壓縮任務交給線程池，避免阻塞當前線程（特別要避免阻塞IO線程）。
由此可見，多線程並不是萬靈丹(silver bullet)。

1：必須使用單線程的場合
據我所知，有兩種場合必須使用單線程：
a：程序可能會fork(2)；
實際編程中，應該保證只有單線程程序能進行fork(2)。多線程程序不是不能調用fork(2)，而是這么做會遇到很多麻煩：
fork一般不能在多線程程序中調用，因為Linux的fork只克隆當前線程的thread of control，不可隆其他線程。fork之後，除了當前線程之外，其他線程都消失了。
這就造成一種危險的局面。其他線程可能正好處於臨界區之內，持有了某個鎖，而它突然死亡，再也沒有機會去解鎖了。此時如果子進程試圖再對同一個mutex加鎖，就會立即死鎖。因此，fork之後，子進程就相當於處於signal handler之中（因為不知道調用fork時，父進程中的線程此時正在調用什麼函數，這和信號發生時的場景一樣），你不能調用線程安全的函數（除非它是可重入的），而只能調用非同步信號安全的函數。比如，fork之後，子進程不能調用：
malloc，因為malloc在訪問全局狀態時幾乎肯定會加鎖；
任何可能分配或釋放內存的函數，比如snprintf；
任何Pthreads函數；
printf系列函數，因為其他線程可能恰好持有stdout/stderr的鎖；
除了man 7 signal中明確列出的信號安全函數之外的任何函數。

因此，多線程中調用fork，唯一安全的做法是fork之後，立即調用exec執行另一個程序，徹底隔斷子進程與父進程的聯系。

在多線程環境中調用fork，產生子進程後。子進程內部只存在一個線程，也就是父進程中調用fork的線程的副本。
使用fork創建子進程時，子進程通過繼承整個地址空間的副本，也從父進程那裡繼承了所有互斥量、讀寫鎖和條件變數的狀態。如果父進程中的某個線程佔有鎖，則子進程同樣佔有這些鎖。問題是子進程並不包含佔有鎖的線程的副本，所以子進程沒有辦法知道它佔有了哪些鎖，並且需要釋放哪些鎖。
盡管Pthread提供了pthread_atfork函數試圖繞過這樣的問題，但是這回使得代碼變得混亂。因此《Programming With Posix Threads》一書的作者說：」Avoid using fork in threaded code except where the child process will immediately exec a new program.」。

b：限製程序的CPU佔用率；
這個很容易理解，比如在一個8核的伺服器上，一個單線程程序即便發生busy-wait，占滿1個core，其CPU使用率也只有12.5%，在這種最壞的情況下，系統還是有87.5%的計算資源可供其他服務進程使用。
因此對於一些輔助性的程序，如果它必須和主要服務進程運行在同一台機器的話，那麼做成單線程的能避免過分搶奪系統的計算資源。

D. 一文讀懂Linux任務間調度原理和整個執行過程

在前文中，我們分析了內核中進程和線程的統一結構體task_struct，並分析進程、線程的創建和派生的過程。在本文中，我們會對任務間調度進行詳細剖析，了解其原理和整個執行過程。由此，進程、線程部分的大體框架就算是介紹完了。本節主要分為三個部分：Linux內核中常見的調度策略，調度的基本結構體以及調度發生的整個流程。下面將詳細展開說明。

Linux 作為一個多任務操作系統，將每個 CPU 的時間劃分為很短的時間片，再通過調度器輪流分配給各個任務使用，因此造成多任務同時運行的錯覺。為了維護 CPU 時間，Linux 通過事先定義的節拍率（內核中表示為 HZ），觸發時間中斷，並使用全局變數 Jiffies 記錄了開機以來的節拍數。每發生一次時間中斷，Jiffies 的值就加 1。節拍率 HZ 是內核的可配選項，可以設置為 100、250、1000 等。不同的系統可能設置不同的數值，可以通過查詢 /boot/config 內核選項來查看它的配置值。

Linux的調度策略主要分為實時任務和普通任務。實時任務需求盡快返回結果，而普通任務則沒有較高的要求。在前文中我們提到了task_struct中調度策略相應的變數為policy，調度優先順序有prio, static_prio, normal_prio, rt_priority幾個。優先順序其實就是一個數值，對於實時進程來說，優先順序的范圍是 0 99；對於普通進程，優先順序的范圍是 100 139。數值越小，優先順序越高。

實時調度策略主要包括以下幾種

普通調度策略主要包括以下幾種：

首先，我們需要一個結構體去執行調度策略，即sched_class。該類有幾種實現方式

普通任務調度實體源碼如下，這裡麵包含了 vruntime 和權重 load_weight，以及對於運行時間的統計。

在調度時，多個任務調度實體會首先區分是實時任務還是普通任務，然後通過以時間為順序的紅黑樹結構組合起來，vruntime 最小的在樹的左側，vruntime最多的在樹的右側。以CFS策略為例，則會選擇紅黑樹最左邊的葉子節點作為下一個將獲得 CPU 的任務。而這顆紅黑樹，我們稱之為運行時隊列（run queue），即struct rq。

其中包含結構體cfs_rq，其定義如下，主要是CFS調度相關的結構體，主要有權值相關變數、vruntime相關變數以及紅黑樹指針，其中結構體rb_root_cached即為紅黑樹的節點

對結構體dl_rq有類似的定義，運行隊列由紅黑樹結構體構成，並按照deadline策略進行管理

對於實施隊列相應的rt_rq則有所不同，並沒有用紅黑樹實現。

下面再看看調度類sched_class，該類以函數指針的形式定義了諸多隊列操作，如

調度類分為下面幾種：

隊列操作中函數指針指向不同策略隊列的實際執行函數函數，在linux/kernel/sched/目錄下，fair.c、idle.c、rt.c等文件對不同類型的策略實現了不同的函數，如fair.c中定義了

以選擇下一個任務為例，CFS對應的是pick_next_task_fair，而rt_rq對應的則是pick_next_task_rt，等等。

由此，我們來總結一下：

有了上述的基本策略和基本調度結構體，我們可以形成大致的骨架，下面就是需要核心的調度流程將其拼湊成一個整體，實現調度系統。調度分為兩種，主動調度和搶占式調度。

說到調用，逃不過核心函數schele()。其中sched_submit_work()函數完成當前任務的收尾工作，以避免出現如死鎖或者IO中斷等情況。之後首先禁止搶占式調度的發生，然後調用__schele()函數完成調度，之後重新打開搶占式調度，如果需要重新調度則會一直重復該過程，否則結束函數。

而__schele()函數則是實際的核心調度函數，該函數主要操作包括選取下一進程和進行上下文切換，而上下文切換又包括用戶態空間切換和內核態的切換。具體的解釋可以參照英文源碼注釋以及中文對各個步驟的注釋。

其中核心函數是獲取下一個任務的pick_next_task()以及上下文切換的context_switch()，下面詳細展開剖析。首先看看pick_next_task()，該函數會根據調度策略分類，調用該類對應的調度函數選擇下一個任務實體。根據前文分析我們知道，最終是在不同的紅黑樹上選擇最左節點作為下一個任務實體並返回。

下面來看看上下文切換。上下文切換主要干兩件事情，一是切換任務空間，也即虛擬內存；二是切換寄存器和 CPU 上下文。關於任務空間的切換放在內存部分的文章中詳細介紹，這里先按下不表，通過任務空間切換實際完成了用戶態的上下文切換工作。下面我們重點看一下內核態切換，即寄存器和CPU上下文的切換。

switch_to()就是寄存器和棧的切換，它調用到了 __switch_to_asm。這是一段匯編代碼，主要用於棧的切換， 其中32位使用esp作為棧頂指針，64位使用rsp，其他部分代碼一致。通過該段匯編代碼我們完成了棧頂指針的切換，並調用__switch_to完成最終TSS的切換。注意switch_to中其實是有三個變數，分別是prev, next, last，而實際在使用時，我們會對last也賦值為prev。這里的設計意圖需要結合一個例子來說明。假設有ABC三個任務，從A調度到B，B到C，最後C回到A，我們假設僅保存prev和next，則流程如下

最終調用__switch_to()函數。該函數中涉及到一個結構體TSS(Task State Segment)，該結構體存放了所有的寄存器。另外還有一個特殊的寄存器TR（Task Register）會指向TSS，我們通過更改TR的值，會觸發硬體保存CPU所有寄存器在當前TSS，並從新的TSS讀取寄存器的值載入入CPU，從而完成一次硬中斷帶來的上下文切換工作。系統初始化的時候，會調用 cpu_init()給每一個 CPU 關聯一個 TSS，然後將 TR 指向這個 TSS，然後在操作系統的運行過程中，TR 就不切換了，永遠指向這個 TSS。當修改TR的值得時候，則為任務調度。

更多Linux內核視頻教程文本資料免費領取後台私信【 內核大禮包 】自行獲取。

在完成了switch_to()的內核態切換後，還有一個重要的函數finish_task_switch()負責善後清理工作。在前面介紹switch_to三個參數的時候我們已經說明了使用last的重要性。而這里為何讓prev和last均賦值為prev，是因為prev在後面沒有需要用到，所以節省了一個指針空間來存儲last。

至此，我們完成了內核態的切換工作，也完成了整個主動調度的過程。

搶占式調度通常發生在兩種情況下。一種是某任務執行時間過長，另一種是當某任務被喚醒的時候。首先看看任務執行時間過長的情況。

該情況需要衡量一個任務的執行時間長短，執行時間過長則發起搶占。在計算機裡面有一個時鍾，會過一段時間觸發一次時鍾中斷，通知操作系統時間又過去一個時鍾周期，通過這種方式可以查看是否是需要搶占的時間點。

時鍾中斷處理函數會調用scheler_tick()。該函數首先取出當前CPU，並由此獲取對應的運行隊列rq和當前任務curr。接著調用該任務的調度類sched_class對應的task_tick()函數進行時間事件處理。

以普通任務隊列為例，對應的調度類為fair_sched_class，對應的時鍾處理函數為task_tick_fair()，該函數會獲取當前的調度實體和運行隊列，並調用entity_tick()函數更新時間。

在entity_tick()中，首先會調用update_curr()更新當前任務的vruntime，然後調用check_preempt_tick()檢測現在是否可以發起搶占。

check_preempt_tick() 先是調用 sched_slice() 函數計算出一個調度周期中該任務運行的實際時間 ideal_runtime。sum_exec_runtime 指任務總共執行的實際時間，prev_sum_exec_runtime 指上次該進程被調度時已經佔用的實際時間，所以 sum_exec_runtime - prev_sum_exec_runtime 就是這次調度佔用實際時間。如果這個時間大於 ideal_runtime，則應該被搶佔了。除了這個條件之外，還會通過 __pick_first_entity 取出紅黑樹中最小的進程。如果當前進程的 vruntime 大於紅黑樹中最小的進程的 vruntime，且差值大於 ideal_runtime，也應該被搶佔了。

如果確認需要被搶占，則會調用resched_curr()函數，該函數會調用set_tsk_need_resched()標記該任務為_TIF_NEED_RESCHED，即該任務應該被搶占。

某些任務會因為中斷而喚醒，如當 I/O 到來的時候，I/O進程往往會被喚醒。在這種時候，如果被喚醒的任務優先順序高於 CPU 上的當前任務，就會觸發搶占。try_to_wake_up() 調用 ttwu_queue() 將這個喚醒的任務添加到隊列當中。ttwu_queue() 再調用 ttwu_do_activate() 激活這個任務。ttwu_do_activate() 調用 ttwu_do_wakeup()。這裡面調用了 check_preempt_curr() 檢查是否應該發生搶占。如果應該發生搶占，也不是直接踢走當前進程，而是將當前進程標記為應該被搶占。

由前面的分析，我們知道了不論是是當前任務執行時間過長還是新任務喚醒，我們均會對現在的任務標記位_TIF_NEED_RESCUED，下面分析實際搶占的發生。真正的搶占還需要一個特定的時機讓正在運行中的進程有機會調用一下 __schele()函數，發起真正的調度。

實際上會調用__schele()函數共有以下幾個時機

從系統調用返回用戶態：以64位為例，系統調用的鏈路為do_syscall_64->syscall_return_slowpath->prepare_exit_to_usermode->exit_to_usermode_loop。在exit_to_usermode_loop中，會檢測是否為_TIF_NEED_RESCHED，如果是則調用__schele()

內核態啟動：內核態的執行中，被搶占的時機一般發生在 preempt_enable() 中。在內核態的執行中，有的操作是不能被中斷的，所以在進行這些操作之前，總是先調用 preempt_disable() 關閉搶占，當再次打開的時候，就是一次內核態代碼被搶占的機會。preempt_enable() 會調用 preempt_count_dec_and_test()，判斷 preempt_count 和 TIF_NEED_RESCHED 是否可以被搶占。如果可以，就調用 preempt_schele->preempt_schele_common->__schele 進行調度。

   本文分析了任務調度的策略、結構體以及整個調度流程，其中關於內存上下文切換的部分尚未詳細敘述，留待內存部分展開剖析。

1、調度相關結構體及函數實現

2、schele核心函數

E. Linux的線程庫為什麼是放在glibc中來實現

線手前粗程的實現有user level thread，kernel-level thread和兩者結合的方式。Linux的實現了kernel-level thread，共享進程地址空間的進程相當於線程。
PThread是user level thread，內核根本不了解其線悔則程的存在，不會對其中的線程進行調度，更不會對其進行代碼實現畢鎮。

F. 進程調度的Linux 原理

1，SCHED_OTHER 分時調度策略，
2，SCHED_FIFO實時調度策略，先到先服務
3，SCHED_RR實時調度策略，時間片輪轉
實時進程將得到優先調用，實時進程根據實時優先順序決定調度權值，分時進程則通過nice和counter值決定權值，nice越小，counter越大，被調度的概率越大，也就是曾經使用了cpu最少的進程將會得到優先調度。
SHCED_RR和SCHED_FIFO的不同：
當採用SHCED_RR策略的進程的時間片用完，系統將重新分配時間片，並置於就緒隊列尾。放在隊列尾保證了所有具有相同優先順序的RR任務的調度公平。
SCHED_FIFO一旦佔用cpu則一直運行。一直運行直到有更高優先順序任務到達或自己放棄。
如果有相同優先順序的實時進程（根據優先順序計算的調度權值是一樣的）已經准備好，FIFO時必須等待該進程主動放棄後才可以運行這個優先順序相同的任務。而RR可以讓每個任務都執行一段時間。
相同點：
RR和FIFO都只用於實時任務。
創建時優先順序大於0(1-99)。
按照可搶占優先順序調度演算法進行。
就緒態的實時任務立即搶占非實時任務。
所有任務都採用linux分時調度策略時。
1，創建任務指定採用分時調度策略，並指定優先順序nice值(-20~19)。
2，將根據每個任務的nice值確定在cpu上的執行時間(counter)。
3，如果沒有等待資源，則將該任務加入到就緒隊列中。
4，調度程序遍歷就緒隊列中的任務，通過對每個任務動態優先順序的計算(counter+20-nice)結果，選擇計算結果最大的一個去運行，當這個時間片用完後(counter減至0)或者主動放棄cpu時，該任務將被放在就緒隊列末尾(時間片用完)或等待隊列(因等待資源而放棄cpu)中。
5，此時調度程序重復上面計算過程，轉到第4步。
6，當調度程序發現所有就緒任務計算所得的權值都為不大於0時，重復第2步。
所有任務都採用FIFO時，
1，創建進程時指定採用FIFO，並設置實時優先順序rt_priority(1-99)。
2，如果沒有等待資源，則將該任務加入到就緒隊列中。
3，調度程序遍歷就緒隊列，根據實時優先順序計算調度權值(1000+rt_priority)，選擇權值最高的任務使用cpu，該FIFO任務將一直佔有cpu直到有優先順序更高的任務就緒(即使優先順序相同也不行)或者主動放棄(等待資源)。
4，調度程序發現有優先順序更高的任務到達(高優先順序任務可能被中斷或定時器任務喚醒，再或被當前運行的任務喚醒，等等)，則調度程序立即在當前任務堆棧中保存當前cpu寄存器的所有數據，重新從高優先順序任務的堆棧中載入寄存器數據到cpu，此時高優先順序的任務開始運行。重復第3步。
5，如果當前任務因等待資源而主動放棄cpu使用權，則該任務將從就緒隊列中刪除，加入等待隊列，此時重復第3步。
所有任務都採用RR調度策略時
1，創建任務時指定調度參數為RR，並設置任務的實時優先順序和nice值(nice值將會轉換為該任務的時間片的長度)。
2，如果沒有等待資源，則將該任務加入到就緒隊列中。
3，調度程序遍歷就緒隊列，根據實時優先順序計算調度權值(1000+rt_priority)，選擇權值最高的任務使用cpu。
4，如果就緒隊列中的RR任務時間片為0，則會根據nice值設置該任務的時間片，同時將該任務放入就緒隊列的末尾。重復步驟3。
5，當前任務由於等待資源而主動退出cpu，則其加入等待隊列中。重復步驟3。
系統中既有分時調度，又有時間片輪轉調度和先進先出調度
1，RR調度和FIFO調度的進程屬於實時進程，以分時調度的進程是非實時進程。
2，當實時進程准備就緒後，如果當前cpu正在運行非實時進程，則實時進程立即搶占非實時進程。
3，RR進程和FIFO進程都採用實時優先順序做為調度的權值標准，RR是FIFO的一個延伸。FIFO時，如果兩個進程的優先順序一樣，則這兩個優先順序一樣的進程具體執行哪一個是由其在隊列中的未知決定的，這樣導致一些不公正性(優先順序是一樣的，為什麼要讓你一直運行？)，如果將兩個優先順序一樣的任務的調度策略都設為RR，則保證了這兩個任務可以循環執行，保證了公平。 調度程序運行時，要在所有處於可運行狀態的進程之中選擇最值得運行的進程投入運行。選擇進程的依據是什麼呢？在每個進程的task_struct 結構中有這么四項：
policy， priority ， counter， rt_priority
這四項就是調度程序選擇進程的依據.其中，policy是進程的調度策略，用來區分兩種進程-實時和普通；priority是進程(實時和普通)的優先順序；counter 是進程剩餘的時間片，它的大小完全由priority決定；rt_priority是實時優先順序，這是實時進程所特有的，用於實時進程間的選擇。
首先，Linux 根據policy從整體上區分實時進程和普通進程，因為實時進程和普通進程度調度是不同的，它們兩者之間，實時進程應該先於普通進程而運行，然後，對於同一類型的不同進程，採用不同的標准來選擇進程：
對於普通進程，Linux採用動態優先調度，選擇進程的依據就是進程counter的大小。進程創建時，優先順序priority被賦一個初值，一般為0～70之間的數字，這個數字同時也是計數器counter的初值，就是說進程創建時兩者是相等的。字面上看，priority是「優先順序」、counter是「計數器」的意思，然而實際上，它們表達的是同一個意思-進程的「時間片」。Priority代表分配給該進程的時間片，counter表示該進程剩餘的時間片。在進程運行過程中，counter不斷減少，而priority保持不變，以便在counter變為0的時候（該進程用完了所分配的時間片）對counter重新賦值。當一個普通進程的時間片用完以後，並不馬上用priority對counter進行賦值，只有所有處於可運行狀態的普通進程的時間片(p->；；counter==0)都用完了以後，才用priority對counter重新賦值，這個普通進程才有了再次被調度的機會。這說明，普通進程運行過程中，counter的減小給了其它進程得以運行的機會，直至counter減為0時才完全放棄對CPU的使用，這就相對於優先順序在動態變化，所以稱之為動態優先調度。至於時間片這個概念，和其他不同操作系統一樣的，Linux的時間單位也是「時鍾滴答」，只是不同操作系統對一個時鍾滴答的定義不同而已（Linux為10ms）。進程的時間片就是指多少個時鍾滴答，比如，若priority為20，則分配給該進程的時間片就為20個時鍾滴答，也就是20*10ms=200ms。Linux中某個進程的調度策略(policy)、優先順序(priority)等可以作為參數由用戶自己決定，具有相當的靈活性。內核創建新進程時分配給進程的時間片預設為200ms(更准確的，應為210ms)，用戶可以通過系統調用改變它。
對於實時進程，Linux採用了兩種調度策略，即FIFO(先來先服務調度)和RR（時間片輪轉調度）。因為實時進程具有一定程度的緊迫性，所以衡量一個實時進程是否應該運行，Linux採用了一個比較固定的標准。實時進程的counter只是用來表示該進程的剩餘時間片，並不作為衡量它是否值得運行的標准，這和普通進程是有區別的。上面已經看到，每個進程有兩個優先順序，實時優先順序就是用來衡量實時進程是否值得運行的。
這一切看來比較麻煩，但實際上Linux中的實現相當簡單。Linux用函數goodness()來衡量一個處於可運行狀態的進程值得運行的程度。該函數綜合了上面提到的各個方面，給每個處於可運行狀態的進程賦予一個權值(weight)，調度程序以這個權值作為選擇進程的唯一依據。
Linux根據policy的值將進程總體上分為實時進程和普通進程，提供了三種調度演算法：一種傳統的Unix調度程序和兩個由POSIX.1b(原名為POSIX.4)操作系統標准所規定的「實時」調度程序。但這種實時只是軟實時，不滿足諸如中斷等待時間等硬實時要求，只是保證了當實時進程需要時一定只把CPU分配給實時進程。
非實時進程有兩種優先順序，一種是靜態優先順序，另一種是動態優先順序。實時進程又增加了第三種優先順序，實時優先順序。優先順序是一些簡單的整數，為了決定應該允許哪一個進程使用CPU的資源，用優先順序代表相對權值-優先順序越高，它得到CPU時間的機會也就越大。
？ 靜態優先順序(priority)-不隨時間而改變，只能由用戶進行修改。它指明了在被迫和其他進程競爭CPU之前，該進程所應該被允許的時間片的最大值（但很可能的，在該時間片耗盡之前，進程就被迫交出了CPU）。
？ 動態優先順序(counter)-只要進程擁有CPU，它就隨著時間不斷減小；當它小於0時，標記進程重新調度。它指明了在這個時間片中所剩餘的時間量。
？ 實時優先順序(rt_priority)-指明這個進程自動把CPU交給哪一個其他進程；較高權值的進程總是優先於較低權值的進程。如果一個進程不是實時進程，其優先順序就是0，所以實時進程總是優先於非實時進程的（但實際上，實時進程也會主動放棄CPU）。
當policy分別為以下值時：
1) SCHED_OTHER：這是普通的用戶進程，進程的預設類型，採用動態優先調度策略，選擇進程的依據主要是根據進程goodness值的大小。這種進程在運行時，可以被高goodness值的進程搶先。
2) SCHED_FIFO：這是一種實時進程，遵守POSIX1.b標準的FIFO(先入先出)調度規則。它會一直運行，直到有一個進程因I/O阻塞，或者主動釋放CPU，或者是CPU被另一個具有更高rt_priority的實時進程搶先。在Linux實現中，SCHED_FIFO進程仍然擁有時間片-只有當時間片用完時它們才被迫釋放CPU。因此，如同POSIX1.b一樣，這樣的進程就象沒有時間片(不是採用分時)一樣運行。Linux中進程仍然保持對其時間片的記錄（不修改counter）主要是為了實現的方便，同時避免在調度代碼的關鍵路徑上出現條件判斷語句 if (！(current->；；policy&；；SCHED_FIFO)){...}-要知道，其他大量非FIFO進程都需要記錄時間片，這種多餘的檢測只會浪費CPU資源。（一種優化措施，不該將執行時間佔10%的代碼的運行時間減少到50%；而是將執行時間佔90%的代碼的運行時間減少到95%。0.9+0.1*0.5=0.95>；；0.1+0.9*0.9=0.91）
3) SCHED_RR：這也是一種實時進程，遵守POSIX1.b標準的RR(循環round-robin)調度規則。除了時間片有些不同外，這種策略與SCHED_FIFO類似。當SCHED_RR進程的時間片用完後，就被放到SCHED_FIFO和SCHED_RR隊列的末尾。
只要系統中有一個實時進程在運行，則任何SCHED_OTHER進程都不能在任何CPU運行。每個實時進程有一個rt_priority，因此，可以按照rt_priority在所有SCHED_RR進程之間分配CPU。其作用與SCHED_OTHER進程的priority作用一樣。只有root用戶能夠用系統調用sched_setscheler，來改變當前進程的類型(sys_nice，sys_setpriority)。
此外，內核還定義了SCHED_YIELD，這並不是一種調度策略，而是截取調度策略的一個附加位。如同前面說明的一樣，如果有其他進程需要CPU，它就提示調度程序釋放CPU。特別要注意的就是這甚至會引起實時進程把CPU釋放給非實時進程。 真正執行調度的函數是schele(void)，它選擇一個最合適的進程執行，並且真正進行上下文切換，使得選中的進程得以執行。而reschele_idle(struct task_struct *p)的作用是為進程選擇一個合適的CPU來執行，如果它選中了某個CPU，則將該CPU上當前運行進程的need_resched標志置為1，然後向它發出一個重新調度的處理機間中斷，使得選中的CPU能夠在中斷處理返回時執行schele函數，真正調度進程p在CPU上執行。在schele()和reschele_idle()中調用了goodness()函數。goodness()函數用來衡量一個處於可運行狀態的進程值得運行的程度。此外，在schele()函數中還調用了schele_tail()函數；在reschele_idle()函數中還調用了reschele_idle_slow()。這些函數的實現對理解SMP的調度非常重要，下面一一分析這些函數。先給出每個函數的主要流程圖，然後給出源代碼，並加註釋。
goodness()函數分析
goodness()函數計算一個處於可運行狀態的進程值得運行的程度。一個任務的goodness是以下因素的函數：正在運行的任務、想要運行的任務、當前的CPU。goodness返回下面兩類值中的一個：1000以下或者1000以上。1000或者1000以上的值只能賦給「實時」進程，從0到999的值只能賦給普通進程。實際上，在單處理器情況下，普通進程的goodness值只使用這個范圍底部的一部分，從0到41。在SMP情況下，SMP模式會優先照顧等待同一個處理器的進程。不過，不管是UP還是SMP，實時進程的goodness值的范圍是從1001到1099。
goodness()函數其實是不會返回-1000的，也不會返回其他負值。由於idle進程的counter值為負，所以如果使用idle進程作為參數調用goodness，就會返回負值，但這是不會發生的。
goodness()是個簡單的函數，但是它是linux調度程序不可缺少的部分。運行隊列中的每個進程每次執行schele時都要調度它，因此它的執行速度必須很快。
//在/kernel/sched.c中
static inline int goodness(struct task_struct * p， int this_cpu， struct mm_struct *this_mm)
{ int weight；
if (p->；；policy ！= SCHED_OTHER) {/*如果是實時進程，則*/
weight = 1000 + p->；；rt_priority；
goto out；
}
/* 將counter的值賦給weight，這就給了進程一個大概的權值，counter中的值表示進程在一個時間片內，剩下要運行的時間.*/
weight = p->；；counter；
if (！weight) /* weight==0，表示該進程的時間片已經用完，則直接轉到標號out*/
goto out；
#ifdef __SMP__
/*在SMP情況下，如果進程將要運行的CPU與進程上次運行的CPU是一樣的，則最有利，因此，假如進程上次運行的CPU與當前CPU一致的話，權值加上PROC_CHANGE_PENALTY，這個宏定義為20。*/
if (p->；；processor == this_cpu)
weight += PROC_CHANGE_PENALTY；
#endif
if (p->；；mm == this_mm) /*進程p與當前運行進程，是同一個進程的不同線程，或者是共享地址空間的不同進程，優先選擇，權值加1*/
weight += 1；
weight += p->；；priority； /* 權值加上進程的優先順序*/
out：
return weight； /* 返回值作為進程調度的唯一依據，誰的權值大，就調度誰運行*/
}
schele()函數分析
schele()函數的作用是，選擇一個合適的進程在CPU上執行，它僅僅根據'goodness'來工作。對於SMP情況，除了計算每個進程的加權平均運行時間外，其他與SMP相關的部分主要由goodness()函數來體現。
流程：
①將prev和next設置為schele最感興趣的兩個進程：其中一個是在調用schele時正在運行的進程(prev)，另外一個應該是接著就給予CPU的進程（next）。注意：prev和next可能是相同的-schele可以重新調度已經獲得cpu的進程.
②中斷處理程序運行「下半部分」.
③內核實時系統部分的實現，循環調度程序（SCHED_RR）通過移動「耗盡的」RR進程-已經用完其時間片的進程-到隊列末尾，這樣具有相同優先順序的其他RR進程就可以獲得CPU了。同時，這補充了耗盡進程的時間片。
④由於代碼的其他部分已經決定了進程必須被移進或移出TASK_RUNNING狀態，所以會經常使用schele，例如，如果進程正在等待的硬體條件已經發生，所以如果必要，這個switch會改變進程的狀態。如果進程已經處於TASK_RUNNING狀態，它就無需處理了。如果它是可以中斷的（等待信號），並且信號已經到達了進程，就返回TASK_RUNNING狀態。在所以其他情況下（例如，進程已經處於TASK_UNINTERRUPTIBLE狀態了），應該從運行隊列中將進程移走。
⑤將p初始化為運行隊列的第一個任務；p會遍歷隊列中的所有任務。
⑥c記錄了運行隊列中所有進程最好的「goodness」-具有最好「goodness」的進程是最易獲得CPU的進程。goodness的值越高越好。
⑦遍歷執行任務鏈表，跟蹤具有最好goodness的進程。
⑧這個循環中只考慮了唯一一個可以調度的進程。在SMP模式下，只有任務不在cpu上運行時，即can_schele宏返回為真時，才會考慮該任務。在UP情況下，can_schele宏返回恆為真.
⑨如果循環結束後，得到c的值為0。說明運行隊列中的所有進程的goodness值都為0。goodness的值為0，意味著進程已經用完它的時間片，或者它已經明確說明要釋放CPU。在這種情況下，schele要重新計算進程的counter；新counter的值是原來值的一半加上進程的靜態優先順序（priortiy），除非進程已經釋放CPU，否則原來counter的值為0。因此，schele通常只是把counter初始化為靜態優先順序。（中斷處理程序和由另一個處理器引起的分支在schele搜尋goodness最大值時都將增加此循環中的計數器，因此由於這個原因計數器可能不會為0。顯然，這很罕見。）在counter的值計算完成後，重新開始執行這個循環，找具有最大goodness的任務。
⑩如果schele已經選擇了一個不同於前面正在執行的進程來調度，那麼就必須掛起原來的進程並允許新的進程運行。這時調用switch_to來進行切換。

G. 「圖文結合」Linux 進程、線程、文件描述符的底層原理

開發十年經驗總結，阿里架構師的手寫Spring boot原理實踐文檔

阿里架構師的這份：Redis核心原理與應用實踐，帶你手撕Redis

Tomcat結構原理詳解

說到進程，恐怕面試中最常見的問題就是線程和進程的關系了，那麼先說一下答案： 在 Linux 系統中，進程和線程幾乎沒有區別 。

Linux 中的進程其實就是一個數據結構，順帶可以理解文件描述符、重定向、管道命令的底層工作原理，最後我們從操作系統的角度看看為什麼說線程和進程基本沒有區別。

首先，抽象地來說，我們的計算機就是這個東西：

這個大的矩形表示計算機的 內存空間 ，其中的小矩形代表 進程 ，左下角的圓形表示 磁碟 ，右下角的圖形表示一些 輸入輸出設備 ，比如滑鼠鍵盤顯示器等等。另外，注意到內存空間被劃分為了兩塊，上半部分表示 用戶空間 ，下半部分表示 內核空間 。

用戶空間裝著用戶進程需要使用的資源，比如你在程序代碼里開一個數組，這個數組肯定存在用戶空間；內核空間存放內核進程需要載入的系統資源，這一些資源一般是不允許用戶訪問的。但是注意有的用戶進程會共享一些內核空間的資源，比如一些動態鏈接庫等等。

我們用 C 語言寫一個 hello 程序，編譯後得到一個可執行文件，在命令行運行就可以列印出一句 hello world，然後程序退出。在操作系統層面，就是新建了一個進程，這個進程將我們編譯出來的可執行文件讀入內存空間，然後執行，最後退出。

你編譯好的那個可執行程序只是一個文件，不是進程，可執行文件必須要載入內存，包裝成一個進程才能真正跑起來。進程是要依靠操作系統創建的，每個進程都有它的固有屬性，比如進程號（PID）、進程狀態、打開的文件等等，進程創建好之後，讀入你的程序，你的程序才被系統執行。

那麼，操作系統是如何創建進程的呢？ 對於操作系統，進程就是一個數據結構 ，我們直接來看 Linux 的源碼：

task_struct 就是 Linux 內核對於一個進程的描述，也可以稱為「進程描述符」。源碼比較復雜，我這里就截取了一小部分比較常見的。

我們主要聊聊 mm 指針和 files 指針。 mm 指向的是進程的虛擬內存，也就是載入資源和可執行文件的地方； files 指針指向一個數組，這個數組里裝著所有該進程打開的文件的指針。

先說 files ，它是一個文件指針數組。一般來說，一個進程會從 files[0] 讀取輸入，將輸出寫入 files[1] ，將錯誤信息寫入 files[2] 。

舉個例子，以我們的角度 C 語言的 printf 函數是向命令行列印字元，但是從進程的角度來看，就是向 files[1] 寫入數據；同理， scanf 函數就是進程試圖從 files[0] 這個文件中讀取數據。

每個進程被創建時， files 的前三位被填入默認值，分別指向標准輸入流、標准輸出流、標准錯誤流。我們常說的「文件描述符」就是指這個文件指針數組的索引 ，所以程序的文件描述符默認情況下 0 是輸入，1 是輸出，2 是錯誤。

我們可以重新畫一幅圖：

對於一般的計算機，輸入流是鍵盤，輸出流是顯示器，錯誤流也是顯示器，所以現在這個進程和內核連了三根線。因為硬體都是由內核管理的，我們的進程需要通過「系統調用」讓內核進程訪問硬體資源。

PS：不要忘了，Linux 中一切都被抽象成文件，設備也是文件，可以進行讀和寫。

如果我們寫的程序需要其他資源，比如打開一個文件進行讀寫，這也很簡單，進行系統調用，讓內核把文件打開，這個文件就會被放到 files 的第 4 個位置，對應文件描述符 3：

明白了這個原理， 輸入重定向 就很好理解了，程序想讀取數據的時候就會去 files[0] 讀取，所以我們只要把 files[0] 指向一個文件，那麼程序就會從這個文件中讀取數據，而不是從鍵盤：

同理， 輸出重定向 就是把 files[1] 指向一個文件，那麼程序的輸出就不會寫入到顯示器，而是寫入到這個文件中：

錯誤重定向也是一樣的，就不再贅述。

管道符其實也是異曲同工，把一個進程的輸出流和另一個進程的輸入流接起一條「管道」，數據就在其中傳遞，不得不說這種設計思想真的很巧妙：

到這里，你可能也看出「Linux 中一切皆文件」設計思路的高明了，不管是設備、另一個進程、socket 套接字還是真正的文件，全部都可以讀寫，統一裝進一個簡單的 files 數組，進程通過簡單的文件描述符訪問相應資源，具體細節交於操作系統，有效解耦，優美高效。

首先要明確的是，多進程和多線程都是並發，都可以提高處理器的利用效率，所以現在的關鍵是，多線程和多進程有啥區別。

為什麼說 Linux 中線程和進程基本沒有區別呢，因為從 Linux 內核的角度來看，並沒有把線程和進程區別對待。

我們知道系統調用 fork() 可以新建一個子進程，函數 pthread() 可以新建一個線程。 但無論線程還是進程，都是用 task_struct 結構表示的，唯一的區別就是共享的數據區域不同 。

換句話說，線程看起來跟進程沒有區別，只是線程的某些數據區域和其父進程是共享的，而子進程是拷貝副本，而不是共享。就比如說， mm 結構和 files 結構在線程中都是共享的，我畫兩張圖你就明白了：

所以說，我們的多線程程序要利用鎖機制，避免多個線程同時往同一區域寫入數據，否則可能造成數據錯亂。

那麼你可能問， 既然進程和線程差不多，而且多進程數據不共享，即不存在數據錯亂的問題，為什麼多線程的使用比多進程普遍得多呢 ？

因為現實中數據共享的並發更普遍呀，比如十個人同時從一個賬戶取十元，我們希望的是這個共享賬戶的余額正確減少一百元，而不是希望每人獲得一個賬戶的拷貝，每個拷貝賬戶減少十元。

當然，必須要說明的是， 只有 Linux 系統將線程看做共享數據的進程 ，不對其做特殊看待 ，其他的很多操作系統是對線程和進程區別對待的，線程有其特有的數據結構，我個人認為不如 Linux 的這種設計簡潔，增加了系統的復雜度。

在 Linux 中新建線程和進程的效率都是很高的，對於新建進程時內存區域拷貝的問題，Linux 採用了 -on-write 的策略優化，也就是並不真正復制父進程的內存空間，而是等到需要寫操作時才去復制。 所以 Linux 中新建進程和新建線程都是很迅速的 。

H. 關於linux下多線程編程

pthread_join 線程停止等待函數沒有調用

pthread_create 線程生成後，沒有等子線程停止，主線程就先停止了。

主線程停止後，整個程序停止，子線程在沒有printf的時候就被結束了。

結論：不是你沒有看到結果，而是在子線程printf("..................\n");之前整個程序就已經停止了。

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>

#define FALSE -1
#define TRUE 0

void *shuchu( void *my )
{
int j;
printf("..................\n");
}
int main()
{
int i = 0;
int rc = 0;
int ret1;
pthread_t p_thread1;
if(0!=(ret1 = pthread_create(&p_thread1, NULL, shuchu, NULL)))printf("sfdfsdfi\n");
printf("[%d]\n",p_thread1);
pthread_join(p_thread1, NULL);
return TRUE;

}

I. linuxsleep(0)一定線程切換

Linuxsleep(0)是Linux內核中的一個系統調用，它可以讓線程在指定的時塵梁間內進入睡眠狀態，從而實現線程切換。它可以用來實現定時器功能，也可以用來實現線程同步。它的原理是，當線程調用linuxsleep(0)時，它會把自己放入睡眠隊列，並且把當前的CPU時間片設置為0，這樣就可以實現線程切換。當睡眠時間到達時，線程會被喚醒，然後繼此昌續執行。派扒運因此，linuxsleep(0)可以用來實現線程切換，從而提高系統的性能。

J. Linux下C/C++ 手寫一個線程池-

在我們日常生活中會遇到許許多多的問題，如果一個服務端要接受很多客戶端的數據，該怎麼辦？多線程並發內存不夠怎麼辦？所以我們需要了解線程池的相關知識。

1.線程池的簡介

線程池是一種多線程處理形式，處理過程中將任務添加到隊列，然後在創建線程後自動啟動這些任務。線程池線程都是後台線程。每個線程都使用默認的堆棧大小，以默認的優先順序運行，並處於多線程單元中。如果某個線程在託管代碼中空閑（如正在等待某個事件）,則線程池將插入另一個輔助線程來使所有處理器保持繁忙。如果所有線程池線程都始終保持繁忙，但隊列中包含掛起的工作，則線程池將在一段時間後創建另一個輔助線程但線程的數目永遠不會超過最大值。超過最大值的線程可以排隊，但他們要等到其他線程完成後才啟動。

2.線程池的組成

1、線程池管理器（ThreadPoolManager）:用於創建並管理線程池

2、工作線程（WorkThread）: 線程池中線程

3、任務介面（Task）:每個任務必須實現的介面，以供工作線程調度任務的執行。

4、任務隊列:用於存放沒有處理的任務。提供一種緩沖機制。

3.線程池的主要優點

1.避免線程太多，使得內存耗盡

2.避免創建與銷毀線程的代價

3.任務與執行分離

1.線程池結構體定義

代碼如下（示例）：

相關視頻推薦

150行代碼，帶你手寫線程池，自行准備linux環境

C++後台開發該學哪些內容，標悔盯准技術路線及面經與演算法該如何刷

學習地址：C/C++Linux伺服器開發/後台架構師【零好陸聲教友前頃育】-學習視頻教程-騰訊課堂

需要更多C/C++ Linux伺服器架構師學習資料加qun 812855908 （資料包括C/C++，Linux，golang技術，內核，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒體，CDN，P2P，K8S，Docker，TCP/IP，協程，DPDK，ffmpeg，大廠面試題 等）

2.介面定義

代碼如下（示例）：

3.回調函數

代碼如下（示例）：

4.全部代碼（加註釋）

代碼如下（示例）：

關於線程池是基本代碼就在上面了，關於編程這一部分內容，我建議大家還是要自己去動手實現，如果只是單純的看了一遍，知識這塊可能會記住，但是操作起來可能就比較吃力，萬事開頭難，只要堅持下去，總會有結果的。