⑴ 如何實現linux下多線程之間的互斥與同步
Linux設備驅動中必須解決的一個問題是多個進程對共享資源的並發訪問，並發訪問會導致競態，linux提供了多種解決競態問題的方式，這些方式適合不同的應用場景。
Linux內核是多進程、多線程的操作系統，它提供了相當完整的內核同步方法。內核同步方法列表如下：
中斷屏蔽
原子操作
自旋鎖
讀寫自旋鎖
順序鎖
信號量
讀寫信號量
BKL（大內核鎖）
Seq鎖
一、並發與競態：
定義：
並發（concurrency）指的是多個執行單元同時、並行被執行，而並發的執行單元對共享資源（硬體資源和軟體上的全局變數、靜態變數等）的訪問則很容易導致競態（race conditions）。
在linux中，主要的競態發生在如下幾種情況：
1、對稱多處理器（SMP）多個CPU
特點是多個CPU使用共同的系統匯流排，因此可訪問共同的外設和存儲器。
2、單CPU內進程與搶占它的進程
3、中斷（硬中斷、軟中斷、Tasklet、底半部）與進程之間
只要並發的多個執行單元存在對共享資源的訪問，競態就有可能發生。
如果中斷處理程序訪問進程正在訪問的資源，則競態也會會發生。
多個中斷之間本身也可能引起並發而導致競態（中斷被更高優先順序的中斷打斷）。
解決競態問題的途徑是保證對共享資源的互斥訪問，所謂互斥訪問就是指一個執行單元在訪問共享資源的時候，其他的執行單元都被禁止訪問。
訪問共享資源的代碼區域被稱為臨界區，臨界區需要以某種互斥機制加以保護，中斷屏蔽，原子操作，自旋鎖，和信號量都是linux設備驅動中可採用的互斥途徑。
臨界區和競爭條件：
所謂臨界區（critical regions）就是訪問和操作共享數據的代碼段，為了避免在臨界區中並發訪問，編程者必須保證這些代碼原子地執行——也就是說，代碼在執行結束前不可被打斷，就如同整個臨界區是一個不可分割的指令一樣，如果兩個執行線程有可能處於同一個臨界區中，那麼就是程序包含一個bug，如果這種情況發生了，我們就稱之為競爭條件（race conditions），避免並發和防止競爭條件被稱為同步。
死鎖：
死鎖的產生需要一定條件：要有一個或多個執行線程和一個或多個資源，每個線程都在等待其中的一個資源，但所有的資源都已經被佔用了，所有線程都在相互等待，但它們永遠不會釋放已經佔有的資源，於是任何線程都無法繼續，這便意味著死鎖的發生。
二、中斷屏蔽
在單CPU范圍內避免競態的一種簡單方法是在進入臨界區之前屏蔽系統的中斷。
由於linux內核的進程調度等操作都依賴中斷來實現，內核搶占進程之間的並發也就得以避免了。
中斷屏蔽的使用方法：
local_irq_disable()//屏蔽中斷
//臨界區
local_irq_enable()//開中斷
特點：
由於linux系統的非同步IO，進程調度等很多重要操作都依賴於中斷，在屏蔽中斷期間所有的中斷都無法得到處理，因此長時間的屏蔽是很危險的，有可能造成數據丟失甚至系統崩潰，這就要求在屏蔽中斷之後，當前的內核執行路徑應當盡快地執行完臨界區的代碼。
中斷屏蔽只能禁止本CPU內的中斷，因此，並不能解決多CPU引發的競態，所以單獨使用中斷屏蔽並不是一個值得推薦的避免競態的方法，它一般和自旋鎖配合使用。
三、原子操作
定義：原子操作指的是在執行過程中不會被別的代碼路徑所中斷的操作。
（原子原本指的是不可分割的微粒，所以原子操作也就是不能夠被分割的指令）
（它保證指令以「原子」的方式執行而不能被打斷）
原子操作是不可分割的，在執行完畢不會被任何其它任務或事件中斷。在單處理器系統(UniProcessor)中，能夠在單條指令中完成的操作都可以認為是" 原子操作"，因為中斷只能發生於指令之間。這也是某些CPU指令系統中引入了test_and_set、test_and_clear等指令用於臨界資源互斥的原因。但是，在對稱多處理器(Symmetric Multi-Processor)結構中就不同了，由於系統中有多個處理器在獨立地運行，即使能在單條指令中完成的操作也有可能受到干擾。我們以decl (遞減指令)為例，這是一個典型的"讀－改－寫"過程，涉及兩次內存訪問。
通俗理解：
原子操作，顧名思義，就是說像原子一樣不可再細分。一個操作是原子操作，意思就是說這個操作是以原子的方式被執行，要一口氣執行完，執行過程不能夠被OS的其他行為打斷，是一個整體的過程，在其執行過程中，OS的其它行為是插不進來的。
分類：linux內核提供了一系列函數來實現內核中的原子操作，分為整型原子操作和位原子操作，共同點是：在任何情況下操作都是原子的，內核代碼可以安全的調用它們而不被打斷。
原子整數操作：
針對整數的原子操作只能對atomic_t類型的數據進行處理，在這里之所以引入了一個特殊的數據類型，而沒有直接使用C語言的int型，主要是出於兩個原因：
第一、讓原子函數只接受atomic_t類型的操作數，可以確保原子操作只與這種特殊類型數據一起使用，同時，這也確保了該類型的數據不會被傳遞給其它任何非原子函數；
第二、使用atomic_t類型確保編譯器不對相應的值進行訪問優化——這點使得原子操作最終接收到正確的內存地址，而不是一個別名，最後就是在不同體系結構上實現原子操作的時候，使用atomic_t可以屏蔽其間的差異。
原子整數操作最常見的用途就是實現計數器。
另一點需要說明原子操作只能保證操作是原子的，要麼完成，要麼不完成，不會有操作一半的可能，但原子操作並不能保證操作的順序性，即它不能保證兩個操作是按某個順序完成的。如果要保證原子操作的順序性，請使用內存屏障指令。
atomic_t和ATOMIC_INIT(i)定義
typedef struct { volatile int counter; } atomic_t;
#define ATOMIC_INIT(i) { (i) }
在你編寫代碼的時候，能使用原子操作的時候，就盡量不要使用復雜的加鎖機制，對多數體系結構來講，原子操作與更復雜的同步方法相比較，給系統帶來的開銷小，對高速緩存行的影響也小，但是，對於那些有高性能要求的代碼，對多種同步方法進行測試比較，不失為一種明智的作法。
原子位操作：
針對位這一級數據進行操作的函數，是對普通的內存地址進行操作的。它的參數是一個指針和一個位號。
為方便其間，內核還提供了一組與上述操作對應的非原子位函數，非原子位函數與原子位函數的操作完全相同，但是，前者不保證原子性，且其名字前綴多兩個下劃線。例如，與test_bit()對應的非原子形式是_test_bit()，如果你不需要原子性操作（比如，如果你已經用鎖保護了自己的數據），那麼這些非原子的位函數相比原子的位函數可能會執行得更快些。
四、自旋鎖
自旋鎖的引入：
如 果每個臨界區都能像增加變數這樣簡單就好了，可惜現實不是這樣，而是臨界區可以跨越多個函數，例如：先得從一個數據結果中移出數據，對其進行格式轉換和解 析，最後再把它加入到另一個數據結構中，整個執行過程必須是原子的，在數據被更新完畢之前，不能有其他代碼讀取這些數據，顯然，簡單的原子操作是無能為力 的（在單處理器系統(UniProcessor)中，能夠在單條指令中完成的操作都可以認為是" 原子操作"，因為中斷只能發生於指令之間），這就需要使用更為復雜的同步方法——鎖來提供保護。
自旋鎖的介紹：
Linux內核中最常見的鎖是自旋鎖（spin lock），自旋鎖最多隻能被一個可執行線程持有，如果一個執行線程試圖獲得一個被爭用（已經被持有）的自旋鎖，那麼該線程就會一直進行忙循環—旋轉—等待鎖重新可用，要是鎖未被爭用，請求鎖的執行線程便能立刻得到它，繼續執行，在任意時間，自旋鎖都可以防止多於一個的執行線程同時進入理解區，注意同一個鎖可以用在多個位置—例如，對於給定數據的所有訪問都可以得到保護和同步。
一個被爭用的自旋鎖使得請求它的線程在等待鎖重新可用時自旋（特別浪費處理器時間），所以自旋鎖不應該被長時間持有，事實上，這點正是使用自旋鎖的初衷，在短期間內進行輕量級加鎖，還可以採取另外的方式來處理對鎖的爭用：讓請求線程睡眠，直到鎖重新可用時再喚醒它，這樣處理器就不必循環等待，可以去執行其他代碼，這也會帶來一定的開銷——這里有兩次明顯的上下文切換， 被阻塞的線程要換出和換入。因此，持有自旋鎖的時間最好小於完成兩次上下文切換的耗時，當然我們大多數人不會無聊到去測量上下文切換的耗時，所以我們讓持 有自旋鎖的時間應盡可能的短就可以了，信號量可以提供上述第二種機制，它使得在發生爭用時，等待的線程能投入睡眠，而不是旋轉。
自旋鎖可以使用在中斷處理程序中（此處不能使用信號量，因為它們會導致睡眠），在中斷處理程序中使用自旋鎖時，一定要在獲取鎖之前，首先禁止本地中斷（在 當前處理器上的中斷請求），否則，中斷處理程序就會打斷正持有鎖的內核代碼，有可能會試圖去爭用這個已經持有的自旋鎖，這樣以來，中斷處理程序就會自旋， 等待該鎖重新可用，但是鎖的持有者在這個中斷處理程序執行完畢前不可能運行，這正是我們在前一章節中提到的雙重請求死鎖，注意，需要關閉的只是當前處理器上的中斷，如果中斷發生在不同的處理器上，即使中斷處理程序在同一鎖上自旋，也不會妨礙鎖的持有者（在不同處理器上）最終釋放鎖。
自旋鎖的簡單理解：
理解自旋鎖最簡單的方法是把它作為一個變數看待，該變數把一個臨界區或者標記為「我當前正在運行，請稍等一會」或者標記為「我當前不在運行，可以被使用」。如果A執行單元首先進入常式，它將持有自旋鎖，當B執行單元試圖進入同一個常式時，將獲知自旋鎖已被持有，需等到A執行單元釋放後才能進入。
自旋鎖的API函數：
其實介紹的幾種信號量和互斥機制，其底層源碼都是使用自旋鎖,可以理解為自旋鎖的再包裝。所以從這里就可以理解為什麼自旋鎖通常可以提供比信號量更高的性能。
自旋鎖是一個互斥設備，他只能會兩個值：「鎖定」和「解鎖」。它通常實現為某個整數之中的單個位。
「測試並設置」的操作必須以原子方式完成。
任何時候，只要內核代碼擁有自旋鎖，在相關CPU上的搶占就會被禁止。
適用於自旋鎖的核心規則：
（1）任何擁有自旋鎖的代碼都必須使原子的，除服務中斷外（某些情況下也不能放棄CPU,如中斷服務也要獲得自旋鎖。為了避免這種鎖陷阱，需要在擁有自旋鎖時禁止中斷），不能放棄CPU（如休眠，休眠可發生在許多無法預期的地方）。否則CPU將有可能永遠自旋下去（死機）。
（2）擁有自旋鎖的時間越短越好。
需 要強調的是，自旋鎖別設計用於多處理器的同步機制，對於單處理器（對於單處理器並且不可搶占的內核來說，自旋鎖什麼也不作），內核在編譯時不會引入自旋鎖 機制，對於可搶占的內核，它僅僅被用於設置內核的搶占機制是否開啟的一個開關，也就是說加鎖和解鎖實際變成了禁止或開啟內核搶占功能。如果內核不支持搶 占，那麼自旋鎖根本就不會編譯到內核中。
內核中使用spinlock_t類型來表示自旋鎖，它定義在：
typedef struct {
raw_spinlock_t raw_lock;
#if defined(CONFIG_PREEMPT) && defined(CONFIG_SMP)
unsigned int break_lock;
#endif
} spinlock_t;
對於不支持SMP的內核來說，struct raw_spinlock_t什麼也沒有，是一個空結構。對於支持多處理器的內核來說，struct raw_spinlock_t定義為
typedef struct {
unsigned int slock;
} raw_spinlock_t;
slock表示了自旋鎖的狀態，「1」表示自旋鎖處於解鎖狀態（UNLOCK），「0」表示自旋鎖處於上鎖狀態（LOCKED）。
break_lock表示當前是否由進程在等待自旋鎖，顯然，它只有在支持搶占的SMP內核上才起作用。
自旋鎖的實現是一個復雜的過程，說它復雜不是因為需要多少代碼或邏輯來實現它，其實它的實現代碼很少。自旋鎖的實現跟體系結構關系密切，核心代碼基本也是由匯編語言寫成，與體協結構相關的核心代碼都放在相關的目錄下，比如。對於我們驅動程序開發人員來說，我們沒有必要了解這么spinlock的內部細節，如果你對它感興趣，請參考閱讀Linux內核源代碼。對於我們驅動的spinlock介面，我們只需包括頭文件。在我們詳細的介紹spinlock的API之前，我們先來看看自旋鎖的一個基本使用格式：
#include
spinlock_t lock = SPIN_LOCK_UNLOCKED;
spin_lock(&lock);
....
spin_unlock(&lock);
從使用上來說，spinlock的API還很簡單的，一般我們會用的的API如下表，其實它們都是定義在中的宏介面，真正的實現在中
#include
SPIN_LOCK_UNLOCKED
DEFINE_SPINLOCK
spin_lock_init( spinlock_t *)
spin_lock(spinlock_t *)
spin_unlock(spinlock_t *)
spin_lock_irq(spinlock_t *)
spin_unlock_irq(spinlock_t *)
spin_lock_irqsace(spinlock_t *，unsigned long flags)
spin_unlock_irqsace(spinlock_t *, unsigned long flags)
spin_trylock(spinlock_t *)
spin_is_locked(spinlock_t *)
• 初始化
spinlock有兩種初始化形式，一種是靜態初始化，一種是動態初始化。對於靜態的spinlock對象，我們用 SPIN_LOCK_UNLOCKED來初始化，它是一個宏。當然，我們也可以把聲明spinlock和初始化它放在一起做，這就是 DEFINE_SPINLOCK宏的工作，因此，下面的兩行代碼是等價的。
DEFINE_SPINLOCK (lock);
spinlock_t lock = SPIN_LOCK_UNLOCKED;
spin_lock_init 函數一般用來初始化動態創建的spinlock_t對象，它的參數是一個指向spinlock_t對象的指針。當然，它也可以初始化一個靜態的沒有初始化的spinlock_t對象。
spinlock_t *lock
......
spin_lock_init(lock);
• 獲取鎖
內核提供了三個函數用於獲取一個自旋鎖。
spin_lock：獲取指定的自旋鎖。
spin_lock_irq：禁止本地中斷並獲取自旋鎖。
spin_lock_irqsace：保存本地中斷狀態，禁止本地中斷並獲取自旋鎖，返回本地中斷狀態。
自旋鎖是可以使用在中斷處理程序中的，這時需要使用具有關閉本地中斷功能的函數，我們推薦使用 spin_lock_irqsave，因為它會保存加鎖前的中斷標志，這樣就會正確恢復解鎖時的中斷標志。如果spin_lock_irq在加鎖時中斷是關閉的，那麼在解鎖時就會錯誤的開啟中斷。
另外兩個同自旋鎖獲取相關的函數是：
spin_trylock()：嘗試獲取自旋鎖，如果獲取失敗則立即返回非0值，否則返回0。
spin_is_locked()：判斷指定的自旋鎖是否已經被獲取了。如果是則返回非0，否則，返回0。
• 釋放鎖
同獲取鎖相對應，內核提供了三個相對的函數來釋放自旋鎖。
spin_unlock：釋放指定的自旋鎖。
spin_unlock_irq：釋放自旋鎖並激活本地中斷。
spin_unlock_irqsave：釋放自旋鎖，並恢復保存的本地中斷狀態。
五、讀寫自旋鎖
如 果臨界區保護的數據是可讀可寫的，那麼只要沒有寫操作，對於讀是可以支持並發操作的。對於這種只要求寫操作是互斥的需求，如果還是使用自旋鎖顯然是無法滿 足這個要求（對於讀操作實在是太浪費了）。為此內核提供了另一種鎖－讀寫自旋鎖，讀自旋鎖也叫共享自旋鎖，寫自旋鎖也叫排他自旋鎖。
讀寫自旋鎖是一種比自旋鎖粒度更小的鎖機制，它保留了「自旋」的概念，但是在寫操作方面，只能最多有一個寫進程，在讀操作方面，同時可以有多個讀執行單元，當然，讀和寫也不能同時進行。
讀寫自旋鎖的使用也普通自旋鎖的使用很類似，首先要初始化讀寫自旋鎖對象：
// 靜態初始化
rwlock_t rwlock = RW_LOCK_UNLOCKED;
//動態初始化
rwlock_t *rwlock;
...
rw_lock_init(rwlock);
在讀操作代碼里對共享數據獲取讀自旋鎖：
read_lock(&rwlock);
...
read_unlock(&rwlock);
在寫操作代碼里為共享數據獲取寫自旋鎖：
write_lock(&rwlock);
...
write_unlock(&rwlock);
需要注意的是，如果有大量的寫操作，會使寫操作自旋在寫自旋鎖上而處於寫飢餓狀態（等待讀自旋鎖的全部釋放），因為讀自旋鎖會自由的獲取讀自旋鎖。
讀寫自旋鎖的函數類似於普通自旋鎖，這里就不一一介紹了，我們把它列在下面的表中。
RW_LOCK_UNLOCKED
rw_lock_init(rwlock_t *)
read_lock(rwlock_t *)
read_unlock(rwlock_t *)
read_lock_irq(rwlock_t *)
read_unlock_irq(rwlock_t *)
read_lock_irqsave(rwlock_t *, unsigned long)
read_unlock_irqsave(rwlock_t *, unsigned long)
write_lock(rwlock_t *)
write_unlock(rwlock_t *)
write_lock_irq(rwlock_t *)
write_unlock_irq(rwlock_t *)
write_lock_irqsave(rwlock_t *, unsigned long)
write_unlock_irqsave(rwlock_t *, unsigned long)
rw_is_locked(rwlock_t *)
六、順序瑣
順序瑣（seqlock）是對讀寫鎖的一種優化，若使用順序瑣，讀執行單元絕不會被寫執行單元阻塞，也就是說，讀執行單元可以在寫執行單元對被順序瑣保護的共享資源進行寫操作時仍然可以繼續讀，而不必等待寫執行單元完成寫操作，寫執行單元也不需要等待所有讀執行單元完成讀操作才去進行寫操作。
但是，寫執行單元與寫執行單元之間仍然是互斥的，即如果有寫執行單元在進行寫操作，其它寫執行單元必須自旋在哪裡，直到寫執行單元釋放了順序瑣。
如果讀執行單元在讀操作期間，寫執行單元已經發生了寫操作，那麼，讀執行單元必須重新讀取數據，以便確保得到的數據是完整的，這種鎖在讀寫同時進行的概率比較小時，性能是非常好的，而且它允許讀寫同時進行，因而更大的提高了並發性，
注意，順序瑣由一個限制，就是它必須被保護的共享資源不含有指針，因為寫執行單元可能使得指針失效，但讀執行單元如果正要訪問該指針，將導致Oops。
七、信號量
Linux中的信號量是一種睡眠鎖，如果有一個任務試圖獲得一個已經被佔用的信號量時，信號量會將其推進一個等待隊列，然後讓其睡眠，這時處理器能重獲自由，從而去執行其它代碼，當持有信號量的進程將信號量釋放後，處於等待隊列中的哪個任務被喚醒，並獲得該信號量。
信號量，或旗標，就是我們在操作系統里學習的經典的P/V原語操作。
P：如果信號量值大於0，則遞減信號量的值，程序繼續執行，否則，睡眠等待信號量大於0。
V：遞增信號量的值，如果遞增的信號量的值大於0，則喚醒等待的進程。
信號量的值確定了同時可以有多少個進程可以同時進入臨界區，如果信號量的初始值始1，這信號量就是互斥信號量（MUTEX）。對於大於1的非0值信號量，也可稱為計數信號量（counting semaphore）。對於一般的驅動程序使用的信號量都是互斥信號量。
類似於自旋鎖，信號量的實現也與體系結構密切相關，具體的實現定義在頭文件中，對於x86_32系統來說，它的定義如下：
struct semaphore {
atomic_t count;
int sleepers;
wait_queue_head_t wait;
};
信號量的初始值count是atomic_t類型的，這是一個原子操作類型，它也是一個內核同步技術，可見信號量是基於原子操作的。我們會在後面原子操作部分對原子操作做詳細介紹。
信號量的使用類似於自旋鎖，包括創建、獲取和釋放。我們還是來先展示信號量的基本使用形式：
static DECLARE_MUTEX(my_sem);
......
if (down_interruptible(&my_sem))
{
return -ERESTARTSYS;
}
......
up(&my_sem)
Linux內核中的信號量函數介面如下：
static DECLARE_SEMAPHORE_GENERIC(name, count);
static DECLARE_MUTEX(name);
seam_init(struct semaphore *, int);
init_MUTEX(struct semaphore *);
init_MUTEX_LOCKED(struct semaphore *)
down_interruptible(struct semaphore *);
down(struct semaphore *)
down_trylock(struct semaphore *)
up(struct semaphore *)
• 初始化信號量
信號量的初始化包括靜態初始化和動態初始化。靜態初始化用於靜態的聲明並初始化信號量。
static DECLARE_SEMAPHORE_GENERIC(name, count);
static DECLARE_MUTEX(name);
對於動態聲明或創建的信號量，可以使用如下函數進行初始化：
seam_init(sem, count);
init_MUTEX(sem);
init_MUTEX_LOCKED(struct semaphore *)
顯然，帶有MUTEX的函數始初始化互斥信號量。LOCKED則初始化信號量為鎖狀態。
• 使用信號量
信號量初始化完成後我們就可以使用它了
down_interruptible(struct semaphore *);
down(struct semaphore *)
down_trylock(struct semaphore *)
up(struct semaphore *)
down函數會嘗試獲取指定的信號量，如果信號量已經被使用了，則進程進入不可中斷的睡眠狀態。down_interruptible則會使進程進入可中斷的睡眠狀態。關於進程狀態的詳細細節，我們在內核的進程管理里在做詳細介紹。
down_trylock嘗試獲取信號量， 如果獲取成功則返回0，失敗則會立即返回非0。
當退出臨界區時使用up函數釋放信號量，如果信號量上的睡眠隊列不為空，則喚醒其中一個等待進程。
八、讀寫信號量
類似於自旋鎖，信號量也有讀寫信號量。讀寫信號量API定義在頭文件中，它的定義其實也是體系結構相關的，因此具體實現定義在頭文件中，以下是x86的例子：
struct rw_semaphore {
signed long count;
spinlock_t wait_lock;
struct list_head wait_list;
};
⑵ linux單進程如何實現多核cpu多線程分配
linux下的單進程多線程的程序，要實現每個線程平均分配到多核cpu，主要有2個方法
1：利用linux系統自己的線程切換機制，有一個服務叫做irqbalance，這個服務是linux系統自帶的，默認會啟動，這個服務的作用就是把多線程平均分配到CPU的每個核上面，只要這個服務不停止，多線程分配就可以自己實現。但是要注意，如果線程函數內部的有某個循環，且該循環內沒有任何系統調用的話，可能會導致這個線程的CPU時間無法被切換出去。也就是占滿CPU現象，此時加個系統調用，例如sleep，線程所佔的CPU時間就可以切換出去了。
2：利用pthread庫自帶的線程親和性設置函數，來設置線程在某個CPU核心上跑，這個需要在程序內部實現。同時注意不要和進程親和性設置搞混淆了
intpthread_setaffinity_np(pthread_tthread,size_tcpusetsize，
constcpu_set_t*cpuset);
intpthread_getaffinity_np(pthread_tthread,size_tcpusetsize,
cpu_set_t*cpuset);
從函數名以及參數名都很明了，唯一需要點解釋下的可能就是cpu_set_t這個結構體了。這個結構體的理解類似於select中的fd_set，可以理解為cpu集，也是通過約定好的宏來進行清除、設置以及判斷：
//初始化，設為空
voidCPU_ZERO(cpu_set_t*set);
//將某個cpu加入cpu集中
voidCPU_SET(intcpu,cpu_set_t*set);
//將某個cpu從cpu集中移出
voidCPU_CLR(intcpu,cpu_set_t*set);
//判斷某個cpu是否已在cpu集中設置了
intCPU_ISSET(intcpu,constcpu_set_t*set);
⑶ Linux 線程同步有哪些方法
一、互斥鎖(mutex)
1.
初始化鎖。在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);
2.
加鎖。對共享資源的訪問，要對互斥量進行加鎖，如果互斥量已經上了鎖，調用線程會阻塞，直到互斥量被解鎖。
int
pthread_mutex_lock(pthread_mutex
*mutex);
int
pthread_mutex_trylock(pthread_mutex_t
*mutex);
3.
解鎖。在完成了對共享資源的訪問後，要對互斥量進行解鎖。
int
pthread_mutex_unlock(pthread_mutex_t
*mutex);
4.
銷毀鎖。鎖在是使用完成後，需要進行銷毀以釋放資源。
int
pthread_mutex_destroy(pthread_mutex
*mutex);
二、條件變數(cond)
1.
初始化條件變數。
靜態態初始化，pthread_cond_t
cond
=
PTHREAD_COND_INITIALIER;
動態初始化，int
pthread_cond_init(pthread_cond_t
*cond,
pthread_condattr_t
*cond_attr);
2.
等待條件成立。釋放鎖,同時阻塞等待條件變數為真才行。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);
3.
激活條件變數。pthread_cond_signal,pthread_cond_broadcast（激活所有等待線程）
int
pthread_cond_signal(pthread_cond_t
*cond);
int
pthread_cond_broadcast(pthread_cond_t
*cond);
//解除所有線程的阻塞
4.
清除條件變數。無線程等待,否則返回EBUSY
int
pthread_cond_destroy(pthread_cond_t
*cond);
三、信號量(sem)
1.
信號量初始化。
int
sem_init
(sem_t
*sem
,
int
pshared,
unsigned
int
value);
這是對由sem指定的信號量進行初始化，設置好它的共享選項(linux
只支持為0，即表示它是當前進程的局部信號量)，然後給它一個初始值VALUE。
2.
等待信號量。給信號量減1，然後等待直到信號量的值大於0。
int
sem_wait(sem_t
*sem);
3.
釋放信號量。信號量值加1。並通知其他等待線程。
int
sem_post(sem_t
*sem);
4.
銷毀信號量。我們用完信號量後都它進行清理。歸還佔有的一切資源。
int
sem_destroy(sem_t
*sem);
⑷ Linux線程及同步
linux多線程
1.線程概述
線程是一個進程內的基本調度單位，也可以稱為輕量級進程。線程是在共享內存空間中並發的多道執行路徑，它們共享一個進程的資源，如文件描述和信號處理。因此，大大減少了上下文切換的開銷。一個進程可以有多個線程，也就
是有多個線程式控制製表及堆棧寄存器，但卻共享一個用戶地址空間。
2.線程實現
線程創建pthread_create()
所需頭文件#include
<pthread.h>
函數原型int
pthread_create
((pthread_t
*thread,
pthread_attr_t
*attr,
thread：線程標識符
attr：線程屬性設置
start_routine：線程函數的起始地址
arg：傳遞給start_routine的參數
函數返回值
成功：0
出錯：-1
線程退出pthread_exit();
所需頭文件#include
<pthread.h>
函數原型void
pthread_exit(void
*retval)
函數傳入值retval:pthread_exit()調用者線程的返回值，可由其他函數如pthread_join
來檢索獲取
等待線程退出並釋放資源pthread_join()
所需頭文件#include
<pthread.h>
函數原型int
pthread_join
((pthread_t
th,
void
**thread_return))
函數傳入值
th：等待線程的標識符
thread_return：用戶定義的指針，用來存儲被等待線程的返回值（不為NULL時）
函數返回值
成功：0
出錯：-1
代碼舉例
1.
#include<pthread.h>
2.
#include<stdio.h>
3.
#include<errno.h>
4.
5.
/*線程1*/
6.
void
thread1()
7.
{
8.
int
i=0;
9.
10.
while(1)
11.
{
12.
printf(thread1:%d/n,i);
13.
if(i>3)
14.
pthread_exit(0);
15.
i++;
16.
sleep(1);
17.
}
18.
}
19.
20.
/*線程2*/
21.
void
thread2()
22.
{
23.
int
i=0;
24.
25.
while(1)
26.
{
27.
printf(thread2:%d/n,i);
28.
if(i>5)
29.
pthread_exit(0);
30.
i++;
31.
sleep(1);
32.
}
33.
}
34.
35.
int
main()
36.
{
37.
pthread_t
t1,t2;
38.
39.
/*創建線程*/
40.
pthread_create(&t1,NULL,(void
*)thread1,NULL);
41.
pthread_create(&t2,NULL,(void
*)thread2,NULL);
42.
/*等待線程退出*/
43.
pthread_join(t1,NULL);
44.
pthread_join(t2,NULL);
45.
return
0;
46.
}
3同步與互斥
<1>互斥鎖
互斥鎖的操作主要包括以下幾個步驟。
•
互斥鎖初始化：pthread_mutex_init
•
互斥鎖上鎖：pthread_mutex_lock
•
互斥鎖判斷上鎖：pthread_mutex_trylock
•
互斥鎖接鎖：pthread_mutex_unlock
•
消除互斥鎖：pthread_mutex_destroy
1.
#include<pthread.h>
2.
#include<stdio.h>
3.
#include<errno.h>
4.
5.
int
i=0;/*共享變數*/
6.
pthread_mutex_t
mutex=PTHREAD_MUTEX_INITIALIZER;/*互斥鎖*/
7.
8.
void
thread1()
9.
{
10.
int
ret;
11.
while(1)
12.
{
13.
14.
15.
ret=pthread_mutex_trylock(&mutex);/*判斷上鎖*/
16.
17.
if(ret!=EBUSY)
18.
{
19.
pthread_mutex_lock(&mutex);/*上鎖*/
20.
printf(This
is
thread1:%d/n,i);
21.
i++;
22.
pthread_mutex_unlock(&mutex);/*解鎖*/
23.
}
24.
sleep(1);
25.
}
26.
}
27.
28.
void
thread2()
29.
{int
ret;
30.
while(1)
31.
{
32.
33.
ret=pthread_mutex_trylock(&mutex);
34.
if(ret!=EBUSY)
35.
{
36.
pthread_mutex_lock(&mutex);
37.
printf(This
is
thread2:%d/n,i);
38.
i++;
39.
pthread_mutex_unlock(&mutex);
40.
}
41.
sleep(1);
42.
}
43.
}
44.
int
main()
45.
{
46.
pthread_t
t1,t2;
47.
pthread_mutex_init(&mutex,NULL);
48.
pthread_create(&t1,NULL,(void
*)thread1,NULL);
49.
pthread_create(&t2,NULL,(void
*)thread2,NULL);
50.
51.
pthread_join(t1,NULL);
52.
pthread_join(t2,NULL);
53.
54.
pthread_mutex_destroy(&mutex);
55.
return
0;
56.
}
<2>信號量
未進行同步處理的兩個線程
1.
#include<pthread.h>
2.
#include<stdio.h>
3.
#include<errno.h>
4.
5.
int
i=0;
6.
void
thread1()
7.
{
8.
9.
while(1)
10.
{
11.
printf(This
is
thread1:%d/n,i);
12.
i++;
13.
sleep(1);
14.
}
15.
}
16.
17.
18.
void
thread2()
19.
{
20.
21.
while(1)
22.
{
23.
printf(This
is
thread2:%d/n,i);
24.
i++;
25.
sleep(1);
26.
}
27.
}
28.
29.
int
main()
30.
{
31.
pthread_t
t1,t2;
32.
33.
pthread_create(&t1,NULL,(void
*)thread1,NULL);
34.
pthread_create(&t2,NULL,(void
*)thread2,NULL);
⑸ 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下如何實現shell多線程編程以提高應用程序的響應
Linux中多線程編程擁有提高應用程序的響應、使多cpu系統更加有效等優點，下面小編將通過Linux下shell多線程編程的例子給大家講解下多線程編程的過程，一起來了解下吧。
#！/bin/bash
#———————————————————————————–
# 此例子說明了一種用wait、read命令模擬多線程的一種技巧
# 此技巧往往用於多主機檢查，比如ssh登錄、ping等等這種單進程比較慢而不耗費cpu的情況
# 還說明了多線程的控制
#———————————————————————————–
function a_sub
{
# 此處定義一個函數，作為一個線程（子進程）
sleep 3 # 線程的作用是sleep 3s
}
tmp_fifofile=「/tmp/$.fifo」 mkfifo $tmp_fifofile # 新建一個fifo類型的文件
exec 6《》$tmp_fifofile # 將fd6指向fifo類型
rm $tmp_fifofile thread=15 # 此處定義線程數
for
（（i=0;i《$thread;i++））;do echo
done 》&6 # 事實上就是在fd6中放置了$thread個回車符
for
（（i=0;i《50;i++））;do # 50次循環，可以理解為50個主機，或其他
read -u6 # 一個read -u6命令執行一次，就從fd6中減去一個回車符，然後向下執行，
# fd6中沒有回車符的時候，就停在這了，從而實現了線程數量控制
{ # 此處子進程開始執行，被放到後台
a_sub &&
{ # 此處可以用來判斷子進程的邏輯
echo 「a_sub is finished」
}
||
{ echo 「sub error」
}
echo 》&6 # 當進程結束以後，再向fd6中加上一個回車符，即補上了read -u6減去的那個
}
& done wait # 等待所有的後檯子進程結束
exec 6》&- # 關閉df6 exit 0
說明：
此程序中的命令
mkfifo tmpfile
和linux中的命令
mknod tmpfile p
效？果相同。區別是mkfifo為POSIX標准，因此推薦使用它。該命令創建了一個先入先出的管道文件，並為其分配文件標志符6。管道文件是進程之間通信的一種方式，注意這一句很重要
exec 6《》$tmp_fifofile # 將fd6指向fifo類型
如果沒有這句，在向文件$tmp_fifofile或者&6寫入數據時，程序會被阻塞，直到有read讀出了管道文件中的數據為止。而執行了上面這一句後就可以在程序運行期間不斷向fifo類型的文件寫入數據而不會阻塞，並且數據會被保存下來以供read程序讀出。
通過運行命令：
time 。/multithread.sh 》/dev/null
最終運算時間： 50/15 = 3組（每組15）+1組（5個《15 組成一個組）= 4組，每組花費時間：3秒，
則 3 * 4 = 12 秒。
傳統非多線程的代碼 運算時間： 50 * 3 = 150 秒。
上面就是Linux下shell多線程編程的實例介紹了，使用多線程編程還能夠改善程序結構，有興趣的朋友不妨試試看吧。