linux線程模型

⑴ linux 多線程編程(二)2019-08-10

三種專門用於線程同步的機制:POSIX信號量,互斥量和條件變數.

在Linux上信號量API有兩組,一組是System V IPC信號量,即PV操作,另外就是POSIX信號量,POSIX信號量的名字都是以sem_開頭.

phshared參數指定信號量的類型,若其值為0,就表示這個信號量是當前進程的局部信號量,否則該信號量可以在多個進程之間共享.value值指定信號量的初始值,一般與下面的sem_wait函數相對應.

其中比較重要的函數sem_wait函數會以原子操作的方式將信號量的值減一,如果信號量的值為零,則sem_wait將會阻塞,信號量的值可以在sem_init函數中的value初始化;sem_trywait函數是sem_wait的非阻塞版本;sem_post函數將以原子的操作對信號量加一,當信號量的值大於0時,其他正在調用sem_wait等待信號量的線程將被喚醒.
這些函數成功時返回0,失敗則返回-1並設置errno.

生產者消費者模型:
生產者對應一個信號量:sem_t procer;
消費者對應一個信號量:sem_t customer;
sem_init(&procer,2)----生產者擁有資源,可以工作;
sem_init(&customer,0)----消費者沒有資源,阻塞;

在訪問公共資源前對互斥量設置（加鎖），確保同一時間只有一個線程訪問數據，在訪問完成後再釋放（解鎖）互斥量.
互斥鎖的運行方式:串列訪問共享資源;
信號量的運行方式:並行訪問共享資源;
互斥量用pthread_mutex_t數據類型表示，在使用互斥量之前，必須使用pthread_mutex_init函數對它進行初始化，注意，使用完畢後需調用pthread_mutex_destroy.

pthread_mutex_init用於初始化互斥鎖，mutexattr用於指定互斥鎖的屬性，若為NULL，則表示默認屬性。除了用這個函數初始化互斥所外，還可以用如下方式初始化：pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER。
pthread_mutex_destroy用於銷毀互斥鎖，以釋放佔用的內核資源，銷毀一個已經加鎖的互斥鎖將導致不可預期的後果。

pthread_mutex_lock以原子操作給一個互斥鎖加鎖。如果目標互斥鎖已經被加鎖，則pthread_mutex_lock則被阻塞，直到該互斥鎖佔有者把它給解鎖.
pthread_mutex_trylock和pthread_mutex_lock類似，不過它始終立即返回，而不論被操作的互斥鎖是否加鎖，是pthread_mutex_lock的非阻塞版本.當目標互斥鎖未被加鎖時，pthread_mutex_trylock進行加鎖操作；否則將返回EBUSY錯誤碼。注意：這里討論的pthread_mutex_lock和pthread_mutex_trylock是針對普通鎖而言的，對於其他類型的鎖，這兩個加鎖函數會有不同的行為.
pthread_mutex_unlock以原子操作方式給一個互斥鎖進行解鎖操作。如果此時有其他線程正在等待這個互斥鎖，則這些線程中的一個將獲得它.

三個列印機輪流列印:

輸出結果:

如果說互斥鎖是用於同步線程對共享數據的訪問的話,那麼條件變數就是用於在線程之間同步共享數據的值.條件變數提供了一種線程之間通信的機制:當某個共享數據達到某個值時,喚醒等待這個共享數據的線程.
條件變數會在條件不滿足的情況下阻塞線程.且條件變數和互斥量一起使用，允許線程以無競爭的方式等待特定的條件發生.

其中pthread_cond_broadcast函數以廣播的形式喚醒所有等待目標條件變數的線程,pthread_cond_signal函數用於喚醒一個等待目標條件變數線程.但有時候我們可能需要喚醒一個固定的線程,可以通過間接的方法實現:定義一個能夠唯一標識目標線程的全局變數,在喚醒等待條件變數的線程前先設置該變數為目標線程,然後採用廣播的方式喚醒所有等待的線程,這些線程被喚醒之後都檢查該變數以判斷是否是自己.

採用條件變數+互斥鎖實現生產者消費者模型:

運行結果:

阻塞隊列+生產者消費者

運行結果:

⑵ Linux的五種IO模型

在linux中，對於一次讀取IO請求（不僅僅是磁碟，還有網路）的操作，數據並不會直接拷貝到用戶程序的用戶空間緩沖區。它首先會被拷貝到操作系統的內核空間，然後才會從操作系統內核的緩沖區拷貝到用戶空間的緩沖區。
大概是這個樣子。

從圖中可以看見，這是分四步進行的，而這四步裡面有些細節，就有了這5種IO模型

前四種為同步IO，後一種為非同步IO，什麼是同步非同步可以看看我之前寫的 同步與非同步，阻塞與非阻塞 。

應用進程發起系統調用後就阻塞了，直到內核buffer拷貝到用戶buffer，發出成功提示後才繼續執行。

適用場景：並發量小的要及時響應的網路應用開發，JavaBIO。
優點：易於開發，不消耗CPU資源（線程阻塞），及時響應。
缺點：不適用與並發量大的網路應用開發，一個請求一個線程，系統開銷大。

應用進程發起系統調用，內核立馬返回一個自己當前的緩沖區的狀態（錯誤或者說成功），假如
為錯誤則隔段時間再系統調用（輪詢），直到返回成功為止。另外再說一點，有人說輪詢之間可以設置一個時間，例如每幾秒執行一次，然後在這段期間程序可以干自己的事情。（這個我不清楚是不是，雖然理論上可以實現，但是我覺得第一種與第二種的區別應該強調的是是否放棄CPU，第二種有點CAS+輪詢這種輕量級鎖的感覺，第一種就是那種重量級鎖的感覺）。

適用場景：並發量小且不用技術響應的網路應用開發
優點：易於開發，可以在輪詢的間斷期間繼續執行程序。
缺點：不適用與並發量大的網路應用開發，一個請求一個線程，系統開銷大。消耗CPU資源（輪詢），不及時響應。

將多個IO注冊到一個復用器上（select，poll，epoll），然後一個進程監視所有注冊進來的IO。
進程阻塞在select上，而不是真正阻塞在IO系統調用上。當其中任意一個注冊的IO的內核緩沖區有了數據，select就會返回（告訴程序內核態緩存有數據了），然後用戶進程再發起調用，數據就從內核態buffer轉到用態buffer（這段期間也是要阻塞的）。

適用場景：並發量大且對響應要求較為高的網路應用開發，JavaNIO
優點：將阻塞從多個進程轉移到了一個select調用身上，假如並發量大的話select調用是不易被阻塞的，或者說阻塞時間短的。
缺點：不易開發，實現難度大，當並發量小的時候還不如同步阻塞模型。

應用程序向內核注冊一個信號處理程序，然後立即返回，當數據准備好了以後（數據到了內核buffer），內核個應用進程一個信號，然後應用進程通過信號處理程序發起系統調用，然後阻塞直達數據從內核buffer復制到用戶buffer。

優點：將阻塞從多個進程轉移到了一個select調用身上，假如並發量大的話select調用是不易被阻塞的，或者說阻塞時間短的。
缺點：不易開發，實現難度大。

以上四個IO模型都可以看出來，到最後用戶進程都要在數據從內核buffer復制到用戶buffer時阻塞，直到內核告訴進程准備成功。這就是同步進程，就是發出一個功能調用時，在沒有得到結果之前，該調用就不返回或繼續執行後續操作。

就是發出一個功能調用時，在沒有得到結果之前，該調用就不返回或繼續執行後續操作

這個就是直到數據完成到用戶buffer才通知。

應用場景：Java AIO，適合高性能高並發應用。
優點：不阻塞，減少了線程切換，
缺點：難以實現，要操作系統支持。

⑶ linux進程、線程及調度演算法（三）

調度策略值得是大家都在ready時，並且CPU已經被調度時，決定誰來運行，誰來被調度。

兩者之間有一定矛盾。
響應的優化，意味著高優先順序會搶占優先順序，會花時間在上下文切換，會影響吞吐。
上下文切換的時間是很短的，幾微妙就能搞定。上下文切換本身對吞吐並多大影響， 重要的是，切換後引起的cpu 的 cache miss.
每次切換APP, 數據都要重新load一次。
Linux 會盡可能的在響應與吞吐之間尋找平衡。比如在編譯linux的時候，會讓你選擇 kernal features -> Preemption model.
搶占模型會影響linux的調度演算法。

所以 ARM 的架構都是big+LITTLE， 一個很猛CPU+ 多個 性能較差的 CPU, 那麼可以把I/O型任務的調度 放在 LITTLE CPU上。需要計算的放在big上。

早期2.6 內核將優先順序劃分了 0-139 bit的優先順序。數值越低，優先順序越高。0-99優先順序 都是 RT（即時響應）的 ，100-139都是非RT的，即normal。
調度的時候 看哪個bitmap 中的 優先順序上有任務ready。可能多個任務哦。

在普通優先順序線程調度中，高優先順序並不代表對低優先順序的絕對優勢。會在不同優先順序進行輪轉。
100 就是比101高，101也會比102高，但100 不會堵著101。
眾屌絲進程在輪轉時，優先順序高的：

初始設置nice值為0，linux 會探測 你是喜歡睡眠，還是幹活。越喜歡睡，linux 越獎勵你，優先順序上升（nice值減少）。越喜歡幹活，優先順序下降（nice值增加）。所以一個進程在linux中，干著干著 優先順序越低，睡著睡著 優先順序越高。

後期linux補丁中

紅黑樹，數據結構， 左邊節點小於右邊節點
同時兼顧了 CPU/IO 和 nice。
數值代表著 進程運行到目前為止的virtual runtime 時間。

（pyhsical runtime） / weight * 1024(系數)。
優先調度 節點值（vruntime）最小的線程。權重weight 其實有nice 來控制。

一個線程一旦被調度到，則物理運行時間增加，vruntime增加，往左邊走。
weight的增加，也導致vruntime減小，往右邊走。
總之 CFS讓線程 從左滾到右，從右滾到左。即照顧了I/O(喜歡睡，分子小) 也 照顧了 nice值低（分母高）.所以 由喜歡睡，nice值又低的線程，最容易被調度到。
自動調整，無需向nice一樣做出獎勵懲罰動作，個人理解權重其實相當於nice

但是 此時 來一個 0-99的線程，進行RT調度，都可以瞬間秒殺你！因為人家不是普通的，是RT的!

一個多線程的進程中，每個線程的調度的策略 如 fifo rr normal, 都可以不同。每一個的優先順序都可以不一樣。
實驗舉例, 創建2個線程，同時開2個：

運行2次，創建兩個進程
sudo renice -n -5(nice -5級別) -g(global)， 會明顯看到 一個進程的CPU佔用率是另一個的 3倍。

為什麼cpu都已經達到200%，為什麼系統不覺得卡呢？因為，我們的線程在未設置優先順序時，是normal調度模式，且是 CPU消耗型 調度級別其實不高。

利用chrt工具，可以將進程 調整為 50 從normal的調度策略 升為RT （fifo）級別的調度策略，會出現：

chrt , nice renice 的調度策略 都是以線程為單位的，以上 設置的將進程下的所有線程進行設置nice值
線程是調度單位，進程不是，進程是資源封裝單位！

兩個同樣死循環的normal優先順序線程，其中一個nice值降低，該線程的CPU 利用率就會比另一個CPU的利用率高。

⑷ 並行技術的發展歷史

線程技術早在20世紀60年代就被提出，但真正應用多線程到操作系統中還是在20世紀80年代中期。現在，多線程技術已經被許多操作系統所支持，包括Windows NT/2000和Linux。
在1999年1月發布的Linux 2.2內核中，進程是通過系統調用fork創建的，新的進程是原來進程的子進程。需要說明的是，在Linux 2.2.x中，不存在真正意義上的線程，Linux中常用的線程Pthread實際上是通過進程來模擬的。
也就是說，Linux中的線程也是通過fork創建的，是「輕」進程。Linux 2.2預設只允許4096個進程/線程同時運行，而高端系統同時要服務上千的用戶，所以這顯然是一個問題。它一度是阻礙Linux進入企業級市場的一大因素。
2001年1月發布的Linux 2.4內核消除了這個限制，並且允許在系統運行中動態調整進程數上限。因此，進程數現在只受制於物理內存的多少。在高端伺服器上，即使只安裝了512MB內存，現在也能輕而易舉地同時支持1.6萬個進程。
在Linux 2.5內核中，已經做了很多改進線程性能的工作。在Linux 2.6中改進的線程模型仍然是由Ingo Molnar 來完成的。它基於一個1:1的線程模型（一個內核線程對應一個用戶線程），包括內核內在的對新NPTL（Native Posix Threading Library）的支持，這個新的NPTL是由Molnar和Ulrich Drepper合作開發的。
2003年12月發布的Linux 2.6內核，對進程調度經過重新編寫，去掉了以前版本中效率不高的演算法。進程標識號（PID）的數目也從3.2萬升到10億。內核內部的大改變之一就是Linux的線程框架被重寫，以使NPTL可以運行其上。

⑸ Linux系統I/O模型及select、poll、epoll原理和應用

理解Linux的IO模型之前，首先要了解一些基本概念，才能理解這些IO模型設計的依據

操作系統使用虛擬內存來映射物理內存，對於32位的操作系統來說，虛擬地址空間為4G（2^32）。操作系統的核心是內核，為了保護用戶進程不能直接操作內核，保證內核安全，操作系統將虛擬地址空間劃分為內核空間和用戶空間。內核可以訪問全部的地址空間，擁有訪問底層硬體設備的許可權，普通的應用程序需要訪問硬體設備必須通過 系統調用 來實現。

對於Linux系統來說，將虛擬內存的最高1G位元組的空間作為內核空間僅供內核使用，低3G位元組的空間供用戶進程使用，稱為用戶空間。

又被稱為標准I/O，大多數文件系統的默認I/O都是緩存I/O。在Linux系統的緩存I/O機制中，操作系統會將I/O的數據緩存在頁緩存（內存）中，也就是數據先被拷貝到內核的緩沖區（內核地址空間），然後才會從內核緩沖區拷貝到應用程序的緩沖區（用戶地址空間）。

這種方式很明顯的缺點就是數據傳輸過程中需要再應用程序地址空間和內核空間進行多次數據拷貝操作，這些操作帶來的CPU以及內存的開銷是非常大的。

由於Linux系統採用的緩存I/O模式，對於一次I/O訪問，以讀操作舉例，數據先會被拷貝到內核緩沖區，然後才會從內核緩沖區拷貝到應用程序的緩存區，當一個read系統調用發生的時候，會經歷兩個階段：

正是因為這兩個狀態，Linux系統才產生了多種不同的網路I/O模式的方案

Linux系統默認情況下所有socke都是blocking的，一個讀操作流程如下：

以UDP socket為例，當用戶進程調用了recvfrom系統調用，如果數據還沒准備好，應用進程被阻塞，內核直到數據到來且將數據從內核緩沖區拷貝到了應用進程緩沖區，然後向用戶進程返回結果，用戶進程才解除block狀態，重新運行起來。

阻塞模行下只是阻塞了當前的應用進程，其他進程還可以執行，不消耗CPU時間，CPU的利用率較高。

Linux可以設置socket為非阻塞的，非阻塞模式下執行一個讀操作流程如下：

當用戶進程發出recvfrom系統調用時，如果kernel中的數據還沒准備好，recvfrom會立即返回一個error結果，不會阻塞用戶進程，用戶進程收到error時知道數據還沒准備好，過一會再調用recvfrom，直到kernel中的數據准備好了，內核就立即將數據拷貝到用戶內存然後返回ok，這個過程需要用戶進程去輪詢內核數據是否准備好。

非阻塞模型下由於要處理更多的系統調用，因此CPU利用率比較低。

應用進程使用sigaction系統調用，內核立即返回，等到kernel數據准備好時會給用戶進程發送一個信號，告訴用戶進程可以進行IO操作了，然後用戶進程再調用IO系統調用如recvfrom，將數據從內核緩沖區拷貝到應用進程。流程如下：

相比於輪詢的方式，不需要多次系統調用輪詢，信號驅動IO的CPU利用率更高。

非同步IO模型與其他模型最大的區別是，非同步IO在系統調用返回的時候所有操作都已經完成，應用進程既不需要等待數據准備，也不需要在數據到來後等待數據從內核緩沖區拷貝到用戶緩沖區，流程如下：

在數據拷貝完成後，kernel會給用戶進程發送一個信號告訴其read操作完成了。

是用select、poll等待數據，可以等待多個socket中的任一個變為可讀，這一過程會被阻塞，當某個套接字數據到來時返回，之後再用recvfrom系統調用把數據從內核緩存區復制到用戶進程，流程如下：

流程類似阻塞IO，甚至比阻塞IO更差，多使用了一個系統調用，但是IO多路復用最大的特點是讓單個進程能同時處理多個IO事件的能力，又被稱為事件驅動IO，相比於多線程模型，IO復用模型不需要線程的創建、切換、銷毀，系統開銷更小，適合高並發的場景。

select是IO多路復用模型的一種實現，當select函數返回後可以通過輪詢fdset來找到就緒的socket。

優點是幾乎所有平台都支持，缺點在於能夠監聽的fd數量有限，Linux系統上一般為1024，是寫死在宏定義中的，要修改需要重新編譯內核。而且每次都要把所有的fd在用戶空間和內核空間拷貝，這個操作是比較耗時的。

poll和select基本相同，不同的是poll沒有最大fd數量限制（實際也會受到物理資源的限制，因為系統的fd數量是有限的），而且提供了更多的時間類型。

總結：select和poll都需要在返回後通過輪詢的方式檢查就緒的socket，事實上同時連的大量socket在一個時刻只有很少的處於就緒狀態，因此隨著監視的描述符數量的變多，其性能也會逐漸下降。

epoll是select和poll的改進版本，更加靈活，沒有描述符限制。epoll使用一個文件描述符管理多個描述符，將用戶關系的文件描述符的事件存放到內核的一個事件表中，這樣在用戶空間和內核空間的只需一次。

epoll_create()用來創建一個epoll句柄。
epoll_ctl() 用於向內核注冊新的描述符或者是改變某個文件描述符的狀態。已注冊的描述符在內核中會被維護在一棵紅黑樹上，通過回調函數內核會將 I/O 准備好的描述符加入到一個就緒鏈表中管理。
epoll_wait() 可以從就緒鏈表中得到事件完成的描述符，因此進程不需要通過輪詢來獲得事件完成的描述符。

當epoll_wait檢測到描述符IO事件發生並且通知給應用程序時，應用程序可以不立即處理該事件，下次調用epoll_wait還會再次通知該事件，支持block和nonblocking socket。

當epoll_wait檢測到描述符IO事件發生並且通知給應用程序時，應用程序需要立即處理該事件，如果不立即處理，下次調用epoll_wait不會再次通知該事件。

ET模式在很大程度上減少了epoll事件被重復觸發的次數，因此效率要比LT模式高。epoll工作在ET模式的時候，必須使用nonblocking socket，以避免由於一個文件句柄的阻塞讀/阻塞寫操作把處理多個文件描述符的任務餓死。

【segmentfault】 Linux IO模式及 select、poll、epoll詳解
【GitHub】 CyC2018/CS-Notes

⑹ 淺談linux 多線程編程和 windows 多線程編程的異同

很早以前就想寫寫linux下多線程編程和windows下的多線程編程了，但是每當寫時又不知道從哪個地方寫起，怎樣把自己知道的東西都寫出來，下面我就談談linux多線程及線程同步，並將它和windows的多線程進行比較，看看他們之間有什麼相同點和不同的地方。
其實最開始我是搞windows下編程的，包括windows編程，windows 驅動，包括usb驅動，ndis驅動,pci驅動，1394驅動等等，同時也一條龍服務，做windows下的應用程序開發，後面慢慢的我又對linux開發產生比較深的興趣和愛好，就轉到搞linux開發了。在接下來的我還會寫一些博客，主要是寫linux編程和windows編程的區別吧，現在想寫的是linux下usb驅動和windows下usb驅動開發的區別，這些都是後話，等我將linux多線程和windows多線程講解完後，我再寫一篇usb驅動，談談windows 和linux usb驅動的東東。好了，言歸正傳。開始將多線程了。
首先我們講講為什麼要採用多線程編程，其實並不是所有的程序都必須採用多線程，有些時候採用多線程，性能還沒有單線程好。所以我們要搞清楚，什麼時候採用多線程。採用多線程的好處如下：
(1)因為多線程彼此之間採用相同的地址空間，共享大部分的數據，這樣和多進程相比，代價比較節儉，因為多進程的話，啟動新的進程必須分配給它獨立的地址空間，這樣需要數據表來維護代碼段，數據段和堆棧段等等。
(2)多線程和多進程相比，一個明顯的優點就是線程之間的通信了，對不同進程來說，它們具有獨立的數據空間，要進行數據的傳遞只能通過通信的方式進行，這種方式不僅費時，而且很不方便。但是對於多線程就不一樣了。他們之間可以直接共享數據，比如最簡單的方式就是共享全局變數。但是共享全部變數也要注意哦，呵呵，必須注意同步，不然後果你知道的。呵呵。
(3)在多cpu的情況下，不同的線程可以運行不同的cpu下，這樣就完全並行了。
反正我覺得在這種情況下，採用多線程比較理想。比如說你要做一個任務分2個步驟，你為提高工作效率，你可以多線程技術，開辟2個線程，第一個線程就做第一步的工作，第2個線程就做第2步的工作。但是你這個時候要注意同步了。因為只有第一步做完才能做第2步的工作。這時，我們可以採用同步技術進行線程之間的通信。
針對這種情況，我們首先講講多線程之間的通信，在windows平台下，多線程之間通信採用的方法主要有：
(1)共享全局變數,這種方法是最容易想到的，呵呵，那就首先講講吧，比如說吧，上面的問題，第一步要向第2步傳遞收據，我們可以之間共享全局變數，讓兩個線程之間傳遞數據，這時主要考慮的就是同步了，因為你後面的線程在對數據進行操作的時候，你第一個線程又改變了數據的內容，你不同步保護，後果很嚴重的。你也知道，這種情況就是讀臟數據了。在這種情況下，我們最容易想到的同步方法就是設置一個bool flag了，比如說在第2個線程還沒有用完數據前，第一個線程不能寫入。有時在2個線程所需的時間不相同的時候，怎樣達到最大效率的同步，就比較麻煩了。咱們可以多開幾個緩沖區進行操作。就像生產者消費者一樣了。如果是2個線程一直在跑的，由於時間不一致，緩沖區遲早會溢出的。在這種情況下就要考慮了，是不讓數據寫入還是讓數據覆蓋掉老的數據，這時候就要具體問題具體分析了。就此打住，呵呵。就是用bool變數控制同步，linux 和windows是一樣的。
既然講道了這里，就再講講其它同步的方法。同樣 針對上面的這個問題，共享全局變數同步問題。除了採用bool變數外，最容易想到的方法就是互斥量了。呵呵，也就是傳說中的加鎖了。windows下加鎖和linux下加鎖是類似的。採用互斥量進行同步，要想進入那段代碼，就先必須獲得互斥量。
linux上互斥量的函數是：
windows下互斥量的函數有：createmutex 創建一個互斥量，然後就是獲得互斥量waitforsingleobject函數，用完了就釋放互斥量ReleaseMutex(hMutex)，當減到0的時候 內核會才會釋放其對象。下面是windows下與互斥的幾個函數原型。
HANDLE WINAPI CreateMutex(
__in LPSECURITY_ATTRIBUTES lpMutexAttributes,
__in BOOL bInitialOwner,
__in LPCTSTR lpName
);
可以可用來創建一個有名或無名的互斥量對象
第一參數 可以指向一個結構體SECURITY_ATTRIBUTES一般可以設為null；
第二參數 指當時的函數是不是感應感應狀態 FALSE為當前擁有者不會創建互斥
第三參數 指明是否是有名的互斥對象 如果是無名 用null就好。
DWORD WINAPI WaitForSingleObject(
__in HANDLE hHandle,
__in DWORD dwMilliseconds
);
第一個是 創建的互斥對象的句柄。第二個是 表示將在多少時間之後返回 如果設為宏INFINITE 則不會返回 直到用戶自己定義返回。
對於linux操作系統，互斥也是類似的，只是函數不同罷了。在linux下，和互斥相關的幾個函數也要閃亮登場了。
pthread_mutex_init函數：初始化一個互斥鎖；
pthread_mutex_destroy函數：注銷一個互斥鎖；
pthread_mutex_lock函數：加鎖，如果不成功，阻塞等待；
pthread_mutex_unlock函數：解鎖；
pthread_mutex_trylock函數：測試加鎖，如果不成功就立即返回，錯誤碼為EBUSY;
至於這些函數的用法，google上一搜，就出來了，呵呵，在這里不多講了。windows下還有一個可以用來保護數據的方法，也是線程同步的方式
就是臨界區了。臨界區和互斥類似。它們之間的區別是，臨界區速度快，但是它只能用來同步同一個進程內的多個線程。臨界區的獲取和釋放函數如下：
EnterCriticalSection() 進入臨界區; LeaveCriticalSection()離開臨界區。 對於多線程共享內存的東東就講到這里了。
(2)採用消息機制進行多線程通信和同步，windows下面的的消息機制的函數用的多的就是postmessage了。Linux下的消息機制，我用的較少，就不在這里說了，如果誰熟悉的，也告訴我，呵呵。
(3)windows下的另外一種線程通信方法就是事件和信號量了。同樣針對我開始舉得例子，2個線程同步，他們之間傳遞信息，可以採用事件(Event)或信號量(Semaphore),比如第一個線程完成生產的數據後，就必須告訴第2個線程，他已經把數據准備好了，你可以來取走了。第2個線程就把數據取走。呵呵，這里可以採用消息機制，當第一個線程准備好數據後，就直接postmessage給第2個線程，按理說採用postmessage一個線程就可以搞定這個問題了。呵呵，不是重點，省略不講了。
對於linux，也有類似的方法，就是條件變數了，呵呵，這里windows和linux就有不同了。要特別講講才行。
對於windows，採用事件和信號量同步時候，都會使用waitforsingleobject進行等待的，這個函數的第一個參數是一個句柄，在這里可以是Event句柄，或Semaphore句柄，第2個參數就是等待的延遲，最終等多久，單位是ms，如果這個參數為INFINITE，那麼就是無限等待了。釋放信號量的函數為ReleaseSemaphore（）；釋放事件的函數為SetEvent。當然使用這些東西都要初始化的。這里就不講了。Msdn一搜，神馬都出來了，呵呵。神馬都是浮雲！
對於linux操作系統，是採用條件變數來實現類似的功能的。Linux的條件變數一般都是和互斥鎖一起使用的，主要的函數有：
pthread_mutex_lock ,
pthread_mutex_unlock,
pthread_cond_init
pthread_cond_signal
pthread_cond_wait
pthread_cond_timewait
為了和windows操作系統進行對比，我用以下表格進行比較：

對照以上表格,總結如下：
(1) Pthread_cleanup_push,Pthread_cleanup_pop：
這一對函數push和pop的作用是當出現異常退出時，做一些清除操作，即當在push和pop函數之間異常退出，包括調用pthread_exit退出，都會執行push裡面的清除函數，如果有多個push，注意是是棧，先執行後面的那個函數，在執行前面的函數，但是注意當在這2個函數之間通過return 退出的話，執不執行push後的函數就看pop函數中的參數是不是為0了。還有當沒有異常退出時，等同於在這裡面return退出的情況，即：當pop函數參數不為0時，執行清除操作，當pop函數參數為0時，不執行push函數中的清除函數。
（2）linux的pthread_cond_signal和SetEvent的不同點
Pthread_cond_singal釋放信號後，當沒有Pthread_cond_wait，信號馬上復位了，這點和SetEvent不同，SetEvent是不會復位的。詳解如下：
條件變數的置位和復位有2種常用模型：第一種模型是當條件變數置位時(signaled)以後，如果當前沒有線程在等待，其狀態會保持為置位(signaled)，直到有等待的線程進入被觸發,其狀態才會變為unsignaled,這種模型以採用Windows平台上的Auto-set Event 為代表。
第2種模型則是Linux平台的pthread所採用的模型，當條件變數置位(signaled)以後，即使當前沒有任何線程在等待，其狀態也會恢復為復位(unsignaled)狀態。
條件變數在Linux平台上的這種模型很難說好壞，在實際應用中，我們可以對
代碼稍加改進就可以避免這種差異的發生。由於這種差異只會發生在觸發沒有被線程等待在條件變數的時刻，因此我們只需要掌握好觸發的時機即可。最簡單的做法是增加一個計數器記錄等待線程的個數，在決定觸發條件變數前檢查該變數即可。
示例 使用 pthread_cond_wait() 和 pthread_cond_signal()
pthread_mutex_t count_lock;
pthread_cond_t count_nonzero;
unsigned count;
decrement_count()
{
pthread_mutex_lock(&count_lock);
while (count == 0)
pthread_cond_wait(&count_nonzero, &count_lock);
count = count - 1;
pthread_mutex_unlock(&count_lock);
}
increment_count()
{
pthread_mutex_lock(&count_lock);
if (count == 0)
pthread_cond_signal(&count_nonzero);
count = count + 1;
pthread_mutex_unlock(&count_lock);
}
(3) 注意Pthread_cond_wait條件返回時互斥鎖的解鎖問題
extern int pthread_cond_wait __P ((pthread_cond_t *__cond,pthread_mutex_t *__mutex));
調用這個函數時,線程解開mutex指向的鎖並被條件變數cond阻塞。線程可以被函數pthread_cond_signal和函數 pthread_cond_broadcast喚醒線程被喚醒後，它將重新檢查判斷條件是否滿足，如果還不滿足，一般說來線程應該仍阻塞在這里，被等待被下一次喚醒。如果在多線程中採用pthread_cond_wait來等待時，會首先釋放互斥鎖，當等待的信號到來時，再次獲得互斥鎖，因此在之後要注意手動解鎖。舉例如下：
#include
#include
#include
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; /*初始化互斥鎖*/
pthread_cond_t cond = PTHREAD_COND_INITIALIZER; //初始化條件變數
void *thread1(void *);
void *thread2(void *);
int i=1;
int main(void)
{
pthread_t t_a;
pthread_t t_b;
pthread_create(&t_a,NULL,thread1,(void *)NULL);/*創建進程t_a*/
pthread_create(&t_b,NULL,thread2,(void *)NULL); /*創建進程t_b*/
pthread_join(t_b, NULL);/*等待進程t_b結束*/
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&cond);
exit(0);
}
void *thread1(void *junk)
{
for(i=1;i<=9;i++)
{
printf("IN one\n");
pthread_mutex_lock(&mutex);//
if(i%3==0)
pthread_cond_signal(&cond);/*，發送信號，通知t_b進程*/
else
printf("thead1:%d\n",i);
pthread_mutex_unlock(&mutex);//*解鎖互斥量*/
printf("Up Mutex\n");
sleep(3);
}
}
void *thread2(void *junk)
{
while(i<9)
{
printf("IN two \n");
pthread_mutex_lock(&mutex);
if(i%3!=0)
pthread_cond_wait(&cond,&mutex);/*等待*/
printf("thread2:%d\n",i);
pthread_mutex_unlock(&mutex);
printf("Down Mutex\n");
sleep(3);
}
}
輸出如下：
IN one
thead1:1
Up Mutex
IN two
IN one
thead1:2
Up Mutex
IN one
thread2:3
Down Mutex
Up Mutex
IN one
thead1:4
Up Mutex
IN two
IN one
thead1:5
Up Mutex
IN one
Up Mutex
thread2:6
Down Mutex
IN two
thread2:6
Down Mutex
IN one
thead1:7
Up Mutex
IN one
thead1:8
Up Mutex
IN two
IN one
Up Mutex
thread2:9
Down Mutex
注意藍色的地方，有2個thread2:6，其實當這個程序多執行幾次，i=3和i=6時有可能多列印幾個，這里就是競爭鎖造成的了。
(4)另外要注意的Pthread_cond_timedwait等待的是絕對時間，這個和WaitForSingleObject是不同的，Pthread_cond_timedwait在網上也有討論。如下：這個問題比較經典，我把它搬過來。
thread_a ：
pthread_mutex_lock(&mutex);
//do something
pthread_mutex_unlock(&mutex)
thread_b：
pthread_mutex_lock(&mutex);
//do something
pthread_cond_timedwait(&cond, &mutex, &tm);
pthread_mutex_unlock(&mutex)
有如上兩個線程thread_a, thread_b,現在如果a已經進入了臨界區，而b同時超時了，那麼b會從pthread_cond_timedwait返回嗎？如果能返回，那豈不是a,b都在臨界區？如果不能返回，那pthread_cond_timedwait的定時豈不是就不準了？
大家討論有價值的2點如下：
（1） pthread_cond_timedwait (pthread_cond_t *cv, pthread_mutex_t *external_mutex, const struct timespec *abstime) -- This function is a time-based variant of pthread_cond_wait. It waits up to abstime amount of time for cv to be notified. If abstime elapses before cv is notified, the function returns back to the caller with an ETIME result, signifying that a timeout has occurred. Even in the case of timeouts, the external_mutex will be locked when pthread_cond_timedwait returns.
（2） 2.1 pthread_cond_timedwait行為和pthread_cond_wait一樣，在返回的時候都要再次lock mutex.
2 .2pthread_cond_timedwait所謂的如果沒有等到條件變數，超時就返回，並不確切。
如果pthread_cond_timedwait超時到了，但是這個時候不能lock臨界區，pthread_cond_timedwait並不會立即返回，但是在pthread_cond_timedwait返回的時候，它仍在臨界區中，且此時返回值為ETIMEDOUT。
關於pthread_cond_timedwait超時返回的問題，我也認同觀點2。
附錄：
int pthread_create(pthread_t *restrict tidp,const pthread_attr_t *restrict_attr,void*（*start_rtn)(void*),void *restrict arg);
返回值：若成功則返回0，否則返回出錯編號
返回成功時，由tidp指向的內存單元被設置為新創建線程的線程ID。attr參數用於制定各種不同的線程屬性。新創建的線程從start_rtn函數的地址開始運行，該函數只有一個無指針參數arg，如果需要向start_rtn函數傳遞的參數不止一個，那麼需要把這些參數放到一個結構中，然後把這個結構的地址作為arg的參數傳入。
linux下用C開發多線程程序，Linux系統下的多線程遵循POSIX線程介面，稱為pthread。
由 restrict 修飾的指針是最初唯一對指針所指向的對象進行存取的方法，僅當第二個指針基於第一個時，才能對對象進行存取。對對象的存取都限定於基於由 restrict 修飾的指針表達式中。 由 restrict 修飾的指針主要用於函數形參，或指向由 malloc() 分配的內存空間。restrict 數據類型不改變程序的語義。 編譯器能通過作出 restrict 修飾的指針是存取對象的唯一方法的假設，更好地優化某些類型的常式。
第一個參數為指向線程標識符的指針。
第二個參數用來設置線程屬性。
第三個參數是線程運行函數的起始地址。
第四個參數是運行函數的參數。
因為pthread不是linux系統的庫，所以在編譯時注意加上-lpthread參數，以調用靜態鏈接庫。
終止線程：
如果在進程中任何一個線程中調用exit或_exit,那麼整個進行會終止，線程正常的退出方式有：
（1） 線程從啟動常式中返回(return)
（2） 線程可以被另一個進程終止（kill）；
（3） 線程自己調用pthread_exit函數
#include
pthread_exit
線程等待：
int pthread_join(pthread_t tid,void **rval_ptr)
函數pthread_join用來等待一個線程的結束。函數原型為：
extern int pthread_join __P (pthread_t __th, void **__thread_return);
第一個參數為被等待的線程標識符，第二個參數為一個用戶定義的指針，它可以用來存儲被等待線程的返回值。這個函數是一個線程阻塞的函數，調用它的函數將一直等待到被等待的線程結束為止，當函數返回時，被等待線程的資源被收回。
對於windows線程的創建東西，就不列舉了，msdn上 一搜就出來了。呵呵。今天就講到這里吧，希望是拋磚引玉，大家一起探討，呵呵。部分內容我也是參考internet的，特此對原作者表示感謝！

⑺ linux系統中線程同步實現機制有哪些

LinuxThread的線程機制

LinuxThreads是目前Linux平台上使用最為廣泛的線程庫，由Xavier Leroy ([email protected]) 負責開發完成，並已綁定在GLIBC中發行。它所實現的就是基於核心輕量級進程的"一對一"線程模型，一個線程實體對應一個核心輕量級進程，而線程之間的 管理在核外函數庫中實現。

1.線程描述數據結構及實現限制

LinuxThreads定義了一個struct _pthread_descr_struct數據結構來描述線程，並使用全局數組變數 __pthread_handles來描述和引用進程所轄線程。在__pthread_handles中的前兩項，LinuxThreads定義了兩個全 局的系統線程：__pthread_initial_thread和__pthread_manager_thread，並用 __pthread_main_thread表徵__pthread_manager_thread的父線程（初始為 __pthread_initial_thread）。

struct _pthread_descr_struct是一個雙環鏈表結構，__pthread_manager_thread所在的鏈表僅包括它 一個元素，實際上，__pthread_manager_thread是一個特殊線程，LinuxThreads僅使用了其中的errno、p_pid、 p_priority等三個域。而__pthread_main_thread所在的鏈則將進程中所有用戶線程串在了一起。經過一系列 pthread_create()之後形成的__pthread_handles數組將如下圖所示：

圖2 __pthread_handles數組結構

新創建的線程將首先在__pthread_handles數組中占據一項，然後通過數據結構中的鏈指針連入以__pthread_main_thread為首指針的鏈表中。這個鏈表的使用在介紹線程的創建和釋放的時候將提到。

LinuxThreads遵循POSIX1003.1c標准，其中對線程庫的實現進行了一些范圍限制，比如進程最大線程數，線程私有數據區大小等等。在 LinuxThreads的實現中，基本遵循這些限制，但也進行了一定的改動，改動的趨勢是放鬆或者說擴大這些限制，使編程更加方便。這些限定宏主要集中 在sysdeps/unix/sysv/linux/bits/local_lim.h（不同平台使用的文件位置不同）中，包括如下幾個：

每進程的私有數據key數，POSIX定義_POSIX_THREAD_KEYS_MAX為128，LinuxThreads使用 PTHREAD_KEYS_MAX，1024；私有數據釋放時允許執行的操作數，LinuxThreads與POSIX一致，定義 PTHREAD_DESTRUCTOR_ITERATIONS為4；每進程的線程數，POSIX定義為64，LinuxThreads增大到1024 （PTHREAD_THREADS_MAX）；線程運行棧最小空間大小，POSIX未指定，LinuxThreads使用 PTHREAD_STACK_MIN，16384（位元組）。

2.管理線程

"一對一"模型的好處之一是線程的調度由核心完成了，而其他諸如線程取消、線程間的同步等工作，都是在核外線程庫中完成的。在LinuxThreads 中，專門為每一個進程構造了一個管理線程，負責處理線程相關的管理工作。當進程第一次調用pthread_create()創建一個線程的時候就會創建 （__clone()）並啟動管理線程。

在一個進程空間內，管理線程與其他線程之間通過一對"管理管道（manager_pipe[2]）"來通訊，該管道在創建管理線程之前創建，在成功啟動 了管理線程之後，管理管道的讀端和寫端分別賦給兩個全局變數__pthread_manager_reader和 __pthread_manager_request，之後，每個用戶線程都通過__pthread_manager_request向管理線程發請求， 但管理線程本身並沒有直接使用__pthread_manager_reader，管道的讀端（manager_pipe[0]）是作為__clone ()的參數之一傳給管理線程的，管理線程的工作主要就是監聽管道讀端，並對從中取出的請求作出反應。

創建管理線程的流程如下所示：
（全局變數pthread_manager_request初值為-1）

圖3 創建管理線程的流程

初始化結束後，在__pthread_manager_thread中記錄了輕量級進程號以及核外分配和管理的線程id， 2*PTHREAD_THREADS_MAX+1這個數值不會與任何常規用戶線程id沖突。管理線程作為pthread_create()的調用者線程的 子線程運行，而pthread_create()所創建的那個用戶線程則是由管理線程來調用clone()創建，因此實際上是管理線程的子線程。（此處子 線程的概念應該當作子進程來理解。）

__pthread_manager()就是管理線程的主循環所在，在進行一系列初始化工作後，進入while(1)循環。在循環中，線程以2秒為 timeout查詢（__poll()）管理管道的讀端。在處理請求前，檢查其父線程（也就是創建manager的主線程）是否已退出，如果已退出就退出 整個進程。如果有退出的子線程需要清理，則調用pthread_reap_children()清理。

然後才是讀取管道中的請求，根據請求類型執行相應操作（switch-case）。具體的請求處理，源碼中比較清楚，這里就不贅述了。

3.線程棧

在LinuxThreads中，管理線程的棧和用戶線程的棧是分離的，管理線程在進程堆中通過malloc()分配一個THREAD_MANAGER_STACK_SIZE位元組的區域作為自己的運行棧。

用戶線程的棧分配辦法隨著體系結構的不同而不同，主要根據兩個宏定義來區分，一個是NEED_SEPARATE_REGISTER_STACK，這個屬 性僅在IA64平台上使用；另一個是FLOATING_STACK宏，在i386等少數平台上使用，此時用戶線程棧由系統決定具體位置並提供保護。與此同 時，用戶還可以通過線程屬性結構來指定使用用戶自定義的棧。因篇幅所限，這里只能分析i386平台所使用的兩種棧組織方式：FLOATING_STACK 方式和用戶自定義方式。

在FLOATING_STACK方式下，LinuxThreads利用mmap()從內核空間中分配8MB空間（i386系統預設的最大棧空間大小，如 果有運行限制（rlimit），則按照運行限制設置），使用mprotect()設置其中第一頁為非訪問區。該8M空間的功能分配如下圖：

圖4 棧結構示意

低地址被保護的頁面用來監測棧溢出。

對於用戶指定的棧，在按照指針對界後，設置線程棧頂，並計算出棧底，不做保護，正確性由用戶自己保證。

不論哪種組織方式，線程描述結構總是位於棧頂緊鄰堆棧的位置。

4.線程id和進程id

每個LinuxThreads線程都同時具有線程id和進程id，其中進程id就是內核所維護的進程號，而線程id則由LinuxThreads分配和維護。

⑻ Linux多進程和線程同步的幾種方式

Linux 線程同步的三種方法
線程的最大特點是資源的共享性，但資源共享中的同步問題是多線程編程的難點。linux下提供了多種方式來處理線程同步，最常用的是互斥鎖、條件變數和信號量。
一、互斥鎖(mutex)
通過鎖機制實現線程間的同步。
初始化鎖。在Linux下，線程的互斥量數據類型是pthread_mutex_t。在使用前,要對它進行初始化。
靜態分配：pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
動態分配：int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutex_attr_t *mutexattr);
加鎖。對共享資源的訪問，要對互斥量進行加鎖，如果互斥量已經上了鎖，調用線程會阻塞，直到互斥量被解鎖。
int pthread_mutex_lock(pthread_mutex *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
解鎖。在完成了對共享資源的訪問後，要對互斥量進行解鎖。
int pthread_mutex_unlock(pthread_mutex_t *mutex);
銷毀鎖。鎖在是使用完成後，需要進行銷毀以釋放資源。
int pthread_mutex_destroy(pthread_mutex *mutex);
[csharp] view plain
#include <cstdio>
#include <cstdlib>
#include <unistd.h>
#include <pthread.h>
#include "iostream"
using namespace std;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int tmp;
void* thread(void *arg)
{
cout << "thread id is " << pthread_self() << endl;
pthread_mutex_lock(&mutex);
tmp = 12;
cout << "Now a is " << tmp << endl;
pthread_mutex_unlock(&mutex);
return NULL;
}
int main()
{
pthread_t id;
cout << "main thread id is " << pthread_self() << endl;
tmp = 3;
cout << "In main func tmp = " << tmp << endl;
if (!pthread_create(&id, NULL, thread, NULL))
{
cout << "Create thread success!" << endl;
}
else
{
cout << "Create thread failed!" << endl;
}
pthread_join(id, NULL);
pthread_mutex_destroy(&mutex);
return 0;
}
//編譯：g++ -o thread testthread.cpp -lpthread
二、條件變數(cond)
互斥鎖不同，條件變數是用來等待而不是用來上鎖的。條件變數用來自動阻塞一個線程，直到某特殊情況發生為止。通常條件變數和互斥鎖同時使用。條件變數分為兩部分: 條件和變數。條件本身是由互斥量保護的。線程在改變條件狀態前先要鎖住互斥量。條件變數使我們可以睡眠等待某種條件出現。條件變數是利用線程間共享的全局變數進行同步的一種機制，主要包括兩個動作：一個線程等待"條件變數的條件成立"而掛起；另一個線程使"條件成立"（給出條件成立信號）。條件的檢測是在互斥鎖的保護下進行的。如果一個條件為假，一個線程自動阻塞，並釋放等待狀態改變的互斥鎖。如果另一個線程改變了條件，它發信號給關聯的條件變數，喚醒一個或多個等待它的線程，重新獲得互斥鎖，重新評價條件。如果兩進程共享可讀寫的內存，條件變數可以被用來實現這兩進程間的線程同步。
初始化條件變數。
靜態態初始化，pthread_cond_t cond = PTHREAD_COND_INITIALIER;
動態初始化，int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);
等待條件成立。釋放鎖,同時阻塞等待條件變數為真才行。timewait()設置等待時間,仍未signal,返回ETIMEOUT(加鎖保證只有一個線程wait)
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
int pthread_cond_timewait(pthread_cond_t *cond,pthread_mutex *mutex,const timespec *abstime);
激活條件變數。pthread_cond_signal,pthread_cond_broadcast（激活所有等待線程）
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond); //解除所有線程的阻塞
清除條件變數。無線程等待,否則返回EBUSY
int pthread_cond_destroy(pthread_cond_t *cond);
[cpp] view plain
#include <stdio.h>
#include <pthread.h>
#include "stdlib.h"
#include "unistd.h"
pthread_mutex_t mutex;
pthread_cond_t cond;
void hander(void *arg)
{
free(arg);
(void)pthread_mutex_unlock(&mutex);
}
void *thread1(void *arg)
{
pthread_cleanup_push(hander, &mutex);
while(1)
{
printf("thread1 is running\n");
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond, &mutex);
printf("thread1 applied the condition\n");
pthread_mutex_unlock(&mutex);
sleep(4);
}
pthread_cleanup_pop(0);
}
void *thread2(void *arg)
{
while(1)
{
printf("thread2 is running\n");
pthread_mutex_lock(&mutex);
pthread_cond_wait(&cond, &mutex);
printf("thread2 applied the condition\n");
pthread_mutex_unlock(&mutex);
sleep(1);
}
}
int main()
{
pthread_t thid1,thid2;
printf("condition variable study!\n");
pthread_mutex_init(&mutex, NULL);
pthread_cond_init(&cond, NULL);
pthread_create(&thid1, NULL, thread1, NULL);
pthread_create(&thid2, NULL, thread2, NULL);
sleep(1);
do
{
pthread_cond_signal(&cond);
}while(1);
sleep(20);
pthread_exit(0);
return 0;
}
[cpp] view plain
#include <pthread.h>
#include <unistd.h>
#include "stdio.h"
#include "stdlib.h"
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
struct node
{
int n_number;
struct node *n_next;
}*head = NULL;

static void cleanup_handler(void *arg)
{
printf("Cleanup handler of second thread./n");
free(arg);
(void)pthread_mutex_unlock(&mtx);
}
static void *thread_func(void *arg)
{
struct node *p = NULL;
pthread_cleanup_push(cleanup_handler, p);
while (1)
{
//這個mutex主要是用來保證pthread_cond_wait的並發性
pthread_mutex_lock(&mtx);
while (head == NULL)
{
//這個while要特別說明一下，單個pthread_cond_wait功能很完善，為何
//這里要有一個while (head == NULL)呢？因為pthread_cond_wait里的線
//程可能會被意外喚醒，如果這個時候head != NULL，則不是我們想要的情況。
//這個時候，應該讓線程繼續進入pthread_cond_wait
// pthread_cond_wait會先解除之前的pthread_mutex_lock鎖定的mtx，
//然後阻塞在等待對列里休眠，直到再次被喚醒(大多數情況下是等待的條件成立
//而被喚醒，喚醒後，該進程會先鎖定先pthread_mutex_lock(&mtx);，再讀取資源
//用這個流程是比較清楚的
pthread_cond_wait(&cond, &mtx);
p = head;
head = head->n_next;
printf("Got %d from front of queue/n", p->n_number);
free(p);
}
pthread_mutex_unlock(&mtx); //臨界區數據操作完畢，釋放互斥鎖
}
pthread_cleanup_pop(0);
return 0;
}
int main(void)
{
pthread_t tid;
int i;
struct node *p;
//子線程會一直等待資源，類似生產者和消費者，但是這里的消費者可以是多個消費者，而
//不僅僅支持普通的單個消費者，這個模型雖然簡單，但是很強大
pthread_create(&tid, NULL, thread_func, NULL);
sleep(1);
for (i = 0; i < 10; i++)
{
p = (struct node*)malloc(sizeof(struct node));
p->n_number = i;
pthread_mutex_lock(&mtx); //需要操作head這個臨界資源，先加鎖，
p->n_next = head;
head = p;
pthread_cond_signal(&cond);
pthread_mutex_unlock(&mtx); //解鎖
sleep(1);
}
printf("thread 1 wanna end the line.So cancel thread 2./n");
//關於pthread_cancel，有一點額外的說明，它是從外部終止子線程，子線程會在最近的取消點，退出
//線程，而在我們的代碼里，最近的取消點肯定就是pthread_cond_wait()了。
pthread_cancel(tid);
pthread_join(tid, NULL);
printf("All done -- exiting/n");
return 0;
}
三、信號量(sem)
如同進程一樣，線程也可以通過信號量來實現通信，雖然是輕量級的。信號量函數的名字都以"sem_"打頭。線程使用的基本信號量函數有四個。
信號量初始化。
int sem_init (sem_t *sem , int pshared, unsigned int value);
這是對由sem指定的信號量進行初始化，設置好它的共享選項(linux 只支持為0，即表示它是當前進程的局部信號量)，然後給它一個初始值VALUE。
等待信號量。給信號量減1，然後等待直到信號量的值大於0。
int sem_wait(sem_t *sem);
釋放信號量。信號量值加1。並通知其他等待線程。
int sem_post(sem_t *sem);
銷毀信號量。我們用完信號量後都它進行清理。歸還佔有的一切資源。
int sem_destroy(sem_t *sem);
[cpp] view plain
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
#include <errno.h>
#define return_if_fail(p) if((p) == 0){printf ("[%s]:func error!/n", __func__);return;}
typedef struct _PrivInfo
{
sem_t s1;
sem_t s2;
time_t end_time;
}PrivInfo;

static void info_init (PrivInfo* thiz);
static void info_destroy (PrivInfo* thiz);
static void* pthread_func_1 (PrivInfo* thiz);
static void* pthread_func_2 (PrivInfo* thiz);

int main (int argc, char** argv)
{
pthread_t pt_1 = 0;
pthread_t pt_2 = 0;
int ret = 0;
PrivInfo* thiz = NULL;
thiz = (PrivInfo* )malloc (sizeof (PrivInfo));
if (thiz == NULL)
{
printf ("[%s]: Failed to malloc priv./n");
return -1;
}
info_init (thiz);
ret = pthread_create (&pt_1, NULL, (void*)pthread_func_1, thiz);
if (ret != 0)
{
perror ("pthread_1_create:");
}
ret = pthread_create (&pt_2, NULL, (void*)pthread_func_2, thiz);
if (ret != 0)
{
perror ("pthread_2_create:");
}
pthread_join (pt_1, NULL);
pthread_join (pt_2, NULL);
info_destroy (thiz);
return 0;
}
static void info_init (PrivInfo* thiz)
{
return_if_fail (thiz != NULL);
thiz->end_time = time(NULL) + 10;
sem_init (&thiz->s1, 0, 1);
sem_init (&thiz->s2, 0, 0);
return;
}
static void info_destroy (PrivInfo* thiz)
{
return_if_fail (thiz != NULL);
sem_destroy (&thiz->s1);
sem_destroy (&thiz->s2);
free (thiz);
thiz = NULL;
return;
}
static void* pthread_func_1 (PrivInfo* thiz)
{
return_if_fail(thiz != NULL);
while (time(NULL) < thiz->end_time)
{
sem_wait (&thiz->s2);
printf ("pthread1: pthread1 get the lock./n");
sem_post (&thiz->s1);
printf ("pthread1: pthread1 unlock/n");
sleep (1);
}
return;
}
static void* pthread_func_2 (PrivInfo* thiz)
{
return_if_fail (thiz != NULL);
while (time (NULL) < thiz->end_time)
{
sem_wait (&thiz->s1);
printf ("pthread2: pthread2 get the unlock./n");
sem_post (&thiz->s2);
printf ("pthread2: pthread2 unlock./n");
sleep (1);
}
return;
}

⑼ linux操作系統多進程和多線程的區別

用ps -eLf 在linux下查看，每一行是一個進程，NLWP列代表這個進程裡面有多少個線程

LWP是輕量級進程的意思

⑽ linux線程為什麼也稱為輕量級進程

輕量級線程(LWP)是一種由內核支持的用戶線程。它是基於內核線程的高級抽象，因此只有先支持內核線程，才能有LWP。每一個進程有一個或多個LWPs，每個LWP由一個內核線程支持。這種模型實際上就是恐龍書上所提到的一對一線程模型。在這種實現的操作系統中，LWP就是用戶線程。
由於每個LWP都與一個特定的內核線程關聯，因此每個LWP都是一個獨立的線程調度單元。即使有一個LWP在系統調用中阻塞，也不會影響整個進程的執行。