一文詳解Linux線程同步

作者簡介：

程磊，一線碼農(nóng)，在某手機公司擔任系統(tǒng)開發(fā)工程師；閱碼場榮譽總編輯；日常喜歡研究內(nèi)核基本原理。

目錄：

一、概念解析

? ? ? 1.1 名詞解釋

? ? ? 1.2 線程同步與防同步

二、線程防同步方法

? ? ? 2.1 時間上防同步

? ? ? 2.2 空間上防同步

? ? ? 2.3 事后防同步

三、原子操作

? ? ? 3.1 int原子操作

? ? ? 3.2 long原子操作

? ? ? 3.3 bit原子操作

四、加鎖機制

? ? ? 4.1 鎖的底層原理

? ? ? 4.2 簡單自旋鎖

? ? ? 4.3 互斥鎖

? ? ? 4.4 信號量

五、per-CPU 變量

六、RCU 簡介

七、序列鎖

八、總結(jié)回顧

?

?一、概念解析 ? ?我們在工作中會經(jīng)常遇到線程同步，那么到底什么是線程同步呢，線程同步的本質(zhì)是什么，線程同步的方法又有哪些，為什么會有這些方法呢？在回答這些問題之前，我們先做幾個名詞解釋，以便建立共同的概念基礎(chǔ)。

1.1 名詞解釋

CPU： 本文中的CPU都是指邏輯CPU。
UP： 單處理器(單CPU)。
SMP： 對稱多處理器(多CPU)。
線程、執(zhí)行流： 線程的本質(zhì)是一個執(zhí)行流，但執(zhí)行流不僅僅有線程，還有ISR、softirq、tasklet，都是執(zhí)行流。本文中說到線程一般是泛指各種執(zhí)行流，除非是在需要區(qū)分不同執(zhí)行流時，線程才特指狹義的線程。
并發(fā)、并行： 并發(fā)是指線程在宏觀上表現(xiàn)為同時執(zhí)行，微觀上可能是同時執(zhí)行也可能是交錯執(zhí)行，并行是指線程在宏觀上是同時執(zhí)行，微觀上也是同時執(zhí)行。
偽并發(fā)、真并發(fā)： 偽并發(fā)就是微觀上是交錯執(zhí)行的并發(fā)，真并發(fā)就是并行。UP上只有偽并發(fā)，SMP上既有偽并發(fā)也有真并發(fā)。
臨界區(qū)： 訪問相同數(shù)據(jù)的代碼段，如果可能會在多個線程中并發(fā)執(zhí)行，就叫做臨界區(qū)，臨界區(qū)可以是一個代碼段被多個線程并發(fā)執(zhí)行，也可以是多個不同的代碼段被多個線程并發(fā)執(zhí)行。
同步： 首先線程同步的同步和同步異步的同步，不是一個意思。線程同步的同步，本文按照字面意思進行解釋，同步就是統(tǒng)一步調(diào)、同時執(zhí)行的意思。
線程同步現(xiàn)象： 線程并發(fā)過程中如果存在臨界區(qū)并發(fā)執(zhí)行的情況，就叫做線程同步現(xiàn)象。
線程防同步機制： 如果發(fā)生線程同步現(xiàn)象，由于臨界區(qū)會訪問共同的數(shù)據(jù)，程序可能就會出錯，因此我們要防止發(fā)生線程同步現(xiàn)象，也就是防止臨界區(qū)并發(fā)執(zhí)行的情況，為此我們采取的防范措施叫做線程防同步機制。

1.2 線程同步與防同步

為什么線程同步叫線程同步，不叫線程防同步，叫線程同步給人的感覺好像就是要讓線程同時執(zhí)行的意思啊。但是實際上線程同步是讓臨界區(qū)不要并發(fā)執(zhí)行的意思，不管你們倆誰先執(zhí)行，只要錯開，誰先誰后執(zhí)行都可以。所以本文后面都采用線程防同步機制、防同步機制等詞。

我小時候一直有個疑惑，感冒藥為啥叫感冒藥，感冒藥是讓人感冒的藥啊，不是應(yīng)該叫治感冒藥才對嗎，治療感冒的藥。后來一想，就沒有讓人感冒的藥，所以感冒藥表達的就是治療感冒的藥，沒必要加個治字。但是同時還有一種藥，叫老鼠藥，是治療老鼠的藥嗎，不是啊，是要毒死老鼠的藥，因為沒有人會給老鼠治病。不過我們那里也有把老鼠藥叫做害老鼠藥的，加個害字，意思更明確，不會有歧義。

因此本文用了兩個詞，同步現(xiàn)象、防同步機制，使得概念更加清晰明確。

說了這么多就是為了闡述一個非常簡單的概念，就是不能同時操作相同的數(shù)據(jù)，因為可能會出錯，所以我們要想辦法防止，這個方法我們把它叫做線程防同步。

還有一個詞是競態(tài)條件(race condition)，很多關(guān)于線程同步的書籍文檔中都有提到，但是我一直沒有理解是啥意思。競態(tài)條件，條件，線程同步和條件也沒啥關(guān)系??；競態(tài)，也不知道是什么意思。再看它的英文，condition有情況的意思，race有賽跑、競爭的意思，是不是要表達賽跑情況、競爭現(xiàn)象，想說兩個線程在競爭賽跑，看誰能先訪問到公共數(shù)據(jù)。我發(fā)現(xiàn)沒有競態(tài)條件這個詞對我們理解線程同步問題一點影響都沒有，有了這個詞反而不明所以，所以我們就忽略這個詞。

?

?二、線程防同步方法

在我們理解了同步現(xiàn)象、防同步機制這個詞后，下面的就很好理解了。同步現(xiàn)象是指同時訪問相同的數(shù)據(jù)，那么如何防止呢，我不讓你同時訪問相同的數(shù)據(jù)不就可以了嘛。因此防同步機制有三大類方法。

2.1 時間上防同步

我不讓你們同時進入臨界區(qū)，這樣就不會同時操作相同的數(shù)據(jù)了，有三種方法：

1.原子操作
對于個別特別簡單特別短的臨界區(qū)，CPU會提供一些原子指令，在一條指令中把多個操作完成，兩個原子指令必然一個在前一個在后地執(zhí)行，不可能同時執(zhí)行。原子指令能防偽并發(fā)和真并發(fā)，適用于UP和SMP。

2.加鎖
對于大部分臨界區(qū)來說，代碼都比較復雜，CPU不可能都去實現(xiàn)原子指令，因此可以在臨界區(qū)的入口處加鎖，同一時間只能有一個線程進入，獲得鎖的線程進入，在臨界區(qū)的出口處再釋放鎖。未獲得鎖的線程在外面等待，等待的方式有兩種，忙等待的叫做自旋鎖，休眠等待的叫做阻塞鎖。根據(jù)臨界區(qū)內(nèi)的數(shù)據(jù)讀寫操作不同，鎖又可以分為單一鎖和讀寫鎖，單一鎖不區(qū)分讀者寫者，所有用戶都互斥；讀寫鎖區(qū)分讀者和寫者，讀者之間可以并行，寫者與讀者、寫者與寫者之間是互斥的。自旋鎖有單一鎖和讀寫鎖，阻塞鎖也有單一鎖和讀寫鎖。自旋鎖只能防真并發(fā)，適用于SMP；休眠鎖能防偽并發(fā)和真并發(fā)，適用于UP和SMP。

3.臨時禁用偽并發(fā)
對于某些由于偽并發(fā)而產(chǎn)生的同步問題，可以通過在臨界區(qū)的入口處禁用此類偽并發(fā)、在臨界區(qū)的出口處再恢復此類偽并發(fā)來解決。這種方式顯然只能防偽并發(fā)，適用于UP和SMP上的單CPU。而自旋鎖只能防真并發(fā)，所以在SMP上經(jīng)常會同時使用這兩種方法，同時防偽并發(fā)和真并發(fā)。

臨時禁用偽并發(fā)有三種情況：

a.禁用中斷
如果線程和中斷、軟中斷和中斷之間會訪問公共數(shù)據(jù)，那么在前者的臨界區(qū)內(nèi)可以臨時禁用后者，也就是禁用中斷，達到防止偽并發(fā)的目的。在后者的臨界區(qū)內(nèi)不用采取措施，因為前者不能搶占后者，但是后者能搶占前者。前者一般會同時使用禁中斷和自旋鎖，禁中斷防止偽并發(fā)，自旋鎖防止真并發(fā)。
b.禁用軟中斷
如果線程和軟中斷會訪問公共數(shù)據(jù)，那么在前者的臨界區(qū)內(nèi)禁用后者，也就是禁用軟中斷，可以達到防止偽并發(fā)的目的。后者不用采取任何措施，因為前者不會搶占后者。前者也可以和自旋鎖并用，同時防止偽并發(fā)和真并發(fā)。
c.禁用搶占
如果線程和線程之間會訪問公共數(shù)據(jù)，那么可以在臨界區(qū)內(nèi)禁用搶占，達到防止偽并發(fā)的目的。禁用搶占也可以和自旋鎖并用，同時防止偽并發(fā)和真并發(fā)。

2.2 空間上防同步

你們可以同時，但是我不讓你們訪問相同的數(shù)據(jù)，有兩種方法：

1. 數(shù)據(jù)分割
把大家都要訪問的公共數(shù)據(jù)分割成N份，各訪問各的。這也有兩種情況：
a. 在SMP上如果多個CPU要經(jīng)常訪問一個全局數(shù)據(jù)，那么可以把這個數(shù)據(jù)拆分成NR_CPU份，每個CPU只訪問自己對應(yīng)的那份，這樣就不存在并發(fā)問題了，這個方法叫做 per-CPU 變量，只能防真并發(fā)，適用于SMP，需要和禁用搶占配合使用。
b. TLS，每個線程都用自己的局部數(shù)據(jù)，這樣就不存在并發(fā)問題了，能防真并發(fā)和偽并發(fā)，適用于UP和SMP。

2. 數(shù)據(jù)復制
RCU，只適用于用指針訪問的動態(tài)數(shù)據(jù)。讀者復制指針，然后就可以隨意讀取數(shù)據(jù)了，所有的讀者可以共同讀一份數(shù)據(jù)。寫者復制數(shù)據(jù)，然后就可以隨意修改復制后的數(shù)據(jù)了，因為這份數(shù)據(jù)是私有的，不過修改完數(shù)據(jù)之后要修改指針指向最新的數(shù)據(jù)，修改指針的這個操作需要是原子的。對于讀者來說，它是復制完指針之后用自己的私有指針來訪問數(shù)據(jù)的，所以它訪問的要么是之前的數(shù)據(jù)，要么是修改之后的數(shù)據(jù)，而不會是不一致的數(shù)據(jù)。能防偽并發(fā)和真并發(fā)，適用于UP和SMP。

2.3 事后防同步

不去積極預防并發(fā)，而是假設(shè)不存在并發(fā)，直接訪問數(shù)據(jù)。訪問完了之后再檢查剛才是否有并發(fā)發(fā)生，如果有就再重來一遍，一直重試，直到?jīng)]有并發(fā)發(fā)生為止。這就是內(nèi)核里面的序列鎖seqlock，能防偽并發(fā)和真并發(fā)，適用于UP和SMP。

下面我們來畫張圖總結(jié)一下：

?

?三、原子操作 ? ?我們在剛開始學習線程同步時，經(jīng)常用來舉的一個例子就是，就連一個簡單的i++操作都是線程不安全的。i++對于源碼來說已經(jīng)是非常簡單的語句了，但是它編譯成機器碼之后有三個指令，把數(shù)據(jù)從內(nèi)存加載到寄存器，把寄存器加1，把寄存器的值加1。如果有兩個線程同時執(zhí)行i++話，就會出問題，比如i最開始等于0，每個線程都循環(huán)一萬次i++，我們期望最后的結(jié)果是兩萬，但是實際上最后的結(jié)果是不到兩萬的。對于UP來說，兩個線程輪流執(zhí)行，如果線程切換的點落在三條指令之間就會出問題。對于SMP來說多個CPU同時執(zhí)行更會出問題。為此我們可以采取的辦法可以是每次i++都加鎖，這樣做當然可以，不過這么做有點殺雞用牛刀了。很多CPU專門為這種基本的整數(shù)操作提供了原子指令。

3.1 int原子操作

硬件提供的都是直接對整數(shù)的原子操作，但是在Linux內(nèi)核里并不是直接對一個int類型進行原子操作，而是對一個封裝后的數(shù)據(jù)進行操作。本質(zhì)上還是對int進行操作，那么為什么要做這么一層封裝呢？主要是為了接口語義，大家一看到一個變量是atomic_t類型的，大家立馬就明白這是一個原子變量，不能使用普通加減操作進行運算，要使用專門的接口函數(shù)來操作才對。

typedef struct {  int counter;}?atomic_t;

那么對于 atomic_t的原子操作都有哪些呢？

Atomic Integer Operation	Description
ATOMIC_INIT(int i)	At declaration, initialize to i
int atomic_read(atomic_t *v)	Atomically read the integer value of v
void atomic_set(atomic_t *v, int i)	Atomically set v equal to i.
void atomic_add(int i, atomic_t *v)	Atomically add i to v
void atomic_sub(int i, atomic_t *v)	Atomically subtract i from v
void atomic_inc(atomic_t *v)	Atomically add one to v
void atomic_dec(atomic_t *v)	Atomically subtract one from v
int atomic_sub_and_test(int i, atomic_t *v)	Atomically subtract i from v and return true if the result is zero; otherwise false.
int atomic_add_negative(int i, atomic_t *v)	Atomically add i to v and return true if the result is negative; otherwise false.
int atomic_add_return(int i, atomic_t *v)	Atomically add i to v and return the result.
int atomic_sub_return(int i, atomic_t *v)	Atomically subtract i from v and return the result.
int atomic_dec_and_test(atomic_t *v)	Atomically decrement v by one and return true if zero; false otherwise
int atomic_inc_and_test(atomic_t *v)	Atomically increment v by one and return true if the result is zero; false otherwise.

3.2 long原子操作

如果上面的int類型(32位)不能滿足我們的原子操作需求，系統(tǒng)還為我們定義了64位的原子變量。

typedef struct {  s64 counter;}?atomic64_t;

同樣的也為我們提供了一堆原子接口：

Atomic Integer Operation	Description
ATOMIC64_INIT(int i)	At declaration, initialize to i
int atomic64_read(atomic_t *v)	Atomically read the integer value of v
void atomic64_set(atomic_t *v, int i)	Atomically set v equal to i.
void atomic64_add(int i, atomic_t *v)	Atomically add i to v
void atomic64_sub(int i, atomic_t *v)	Atomically subtract i from v
void atomic64_inc(atomic_t *v)	Atomically add one to v
void atomic64_dec(atomic_t *v)	Atomically subtract one from v
int atomic64_sub_and_test(int i, atomic_t *v)	Atomically subtract i from v and return true if the result is zero; otherwise false.
int atomic64_add_negative(int i, atomic_t *v)	Atomically add i to v and return true if the result is negative; otherwise false.
int atomic64_add_return(int i, atomic_t *v)	Atomically add i to v and return the result.
int atomic64_sub_return(int i, atomic_t *v)	Atomically subtract i from v and return the result.
int atomic64_dec_and_test(atomic_t *v)	Atomically decrement v by one and return true if zero; false otherwise
int atomic64_inc_and_test(atomic_t *v)	Atomically increment v by one and return true if the result is zero; false otherwise.

3.3 bit原子操作

系統(tǒng)還給我們提供了位運算的原子操作，不過并沒有封裝數(shù)據(jù)類型，而是操作一個void * 指針所指向的數(shù)據(jù)，我們要操作的位數(shù)要在我們希望的數(shù)據(jù)之內(nèi)，這點是由我們自己來保證的。

Atomic Bitwise Operation	Description
void set_bit(int nr, void *addr)	Atomically set the nr-th bit starting from addr.
void clear_bit(int nr, void *addr)	Atomically clear the nr-th bit starting from addr.
void change_bit(int nr, void *addr)	Atomically flip the value of the nr-th bit starting from addr.
int test_and_set_bit(int nr, void *addr)	Atomically set the nr-th bit starting from addr and return the previous value.
int test_and_clear_bit(int nr, void *addr)	Atomically clear the nr-th bit starting from addr and return the previous value.
int test_and_change_bit(int nr, void *addr)	Atomically flip the nr-th bit starting from addr and return the previous value.
int test_bit(int nr, void *addr)	Atomically return the value of the nrth bit starting from addr.

有了原子操作，我們對這些簡單的基本運算就不用使用加鎖機制了，就可以提高效率。

?

?四、加鎖機制 ? ?有很多臨界區(qū)，并不是一些簡單的整數(shù)運算，不可能要求硬件都給提供原子操作。為此，我們需要鎖機制，在臨界區(qū)的入口進行加鎖操作，加到鎖的才能進入臨界區(qū)進行操作，加不到鎖的要一直在臨界區(qū)外面等候。等候的方式有兩種，一種是忙等待，就是自旋鎖，一種是休眠等待，就是阻塞鎖，阻塞鎖在Linux里面的實現(xiàn)叫做互斥鎖。

4.1 鎖的底層原理

我們該如何實現(xiàn)一個鎖呢，下面我們嘗試直接用軟件來實現(xiàn)試試，代碼如下：

int lock = 0;
void lock(int * lock){start:  if(*lock == 0)    *lock = 1;  else{    wait();    goto start;  }}
void unlock(int * lock){  *lock = 0;  wakeup();}

可以看到這個鎖的實現(xiàn)邏輯很簡單，定義一個整數(shù)作為鎖，0代表沒人持鎖，1代表有人持鎖。我們先判斷鎖的值，如果是0代表沒人持鎖，我們給鎖賦值1，代表我們獲得了鎖，然后函數(shù)返回，就可以進入臨界區(qū)了。如果鎖是1，代表有人已經(jīng)持有了鎖，此時我們就需要等待，等待函數(shù)wait，可以用忙等待，也可以用休眠等待。釋放鎖的時候把鎖設(shè)為0，然后wakeup其他線程或者為空操作。被喚醒的線程從wait中醒來，然后又重走加鎖流程。但是這里面有個問題，就是加鎖操作也是個臨界區(qū)，如果兩個線程在兩個CPU上同時執(zhí)行到加鎖函數(shù)，雙方都檢測到鎖是0，然后都把鎖置為1，都加鎖成功，這不是出問題了嗎。鎖就是用來保護臨界區(qū)的，但是加鎖本身也是臨界區(qū)，也需要保護，該怎么辦呢？唯一的方法就是求助于硬件，讓加鎖操作成為原子操作，X86平臺提供了CAS指令來實現(xiàn)這個功能。CAS，Compare and Swap，比較并交換，它的接口邏輯是這樣的：

int?cas(int?*?p,?old_value,?new_value)

如果p位置的值等于old_value，就把p位置的值設(shè)置為new_value，并返回1，否則返回0。關(guān)鍵就在于cas它是硬件實現(xiàn)的，是原子的。這樣我們就可以用cas指令來實現(xiàn)鎖的邏輯，如下所示：

int lock = 0;
void lock(int * lock){start:  if(cas(lock, 0, 1))    return;  else{    wait();    goto start;  }}
void unlock(int * lock){  *lock = 0;  wakeup();}

4.2 簡單自旋鎖

為什么在這里要先講簡單自旋鎖呢？因為互斥鎖、信號量這些鎖的內(nèi)部實現(xiàn)都用了自旋鎖，所以先把自旋鎖的邏輯講清楚才能繼續(xù)講下去。為什么是簡單自旋鎖呢，因為自旋鎖現(xiàn)在已經(jīng)發(fā)展得很復雜了，所以這里就是講一下自旋鎖的簡單版本，因為它們的基本邏輯是一致的。自旋鎖由于在加鎖失敗時是忙等待，所以不用考慮等待隊列、睡眠喚醒的問題，所以實現(xiàn)比較簡單，下面是簡單自旋鎖的實現(xiàn)代碼：

int lock = 0;
void spin_lock(int * lock){  while(!cas(lock, 0, 1))}
void spin_unlock(int * lock){  *lock = 0;}

可以看到簡單自旋鎖的代碼是相當簡單，加鎖的時候不停地嘗試加鎖，一直失敗一直加，直到成功才返回。釋放鎖的時候更簡單，直接把鎖置為0就可以了。此時如果有其它自旋鎖在自旋，由于鎖已經(jīng)變成了0，所以就會加鎖成功，結(jié)束自旋。注意這個代碼只是自旋鎖的邏輯演示，并不是真正的自旋鎖實現(xiàn)。

4.3 互斥鎖

互斥鎖是休眠鎖，加鎖失敗時要把自己放入等待隊列，釋放鎖的時候要考慮喚醒等待隊列的線程。互斥鎖的定義如下(刪除了一些配置選項)：

struct mutex {  atomic_long_t    owner;  raw_spinlock_t    wait_lock;  struct list_head  wait_list;};

可以看到互斥鎖的定義有atomic_long_t owner，這個和我們之前定義的int lock是相似的，只不過這里是個加強版，0代表沒加鎖，加鎖的時候是非0，而不是簡單的1，而是記錄的是加鎖的線程。然后是自旋鎖和等待隊列，自旋鎖是用來保護等待隊列的。這里的自旋鎖為什么要用raw_spinlock_t呢，它和spinlock_t有什么區(qū)別呢？在標準的內(nèi)核版本下是沒有區(qū)別的，如果打了RTLinux補丁之后它們就不一樣了，spinlock_t會轉(zhuǎn)化為阻塞鎖，raw_spinlock_t還是自旋鎖，如果需要在任何情況下都要自旋的話請使用raw_spinlock_t。下面我們看一下它的加鎖操作：

void __sched mutex_lock(struct mutex *lock){  might_sleep();
  if (!__mutex_trylock_fast(lock))    __mutex_lock_slowpath(lock);}static __always_inline bool __mutex_trylock_fast(struct mutex *lock){  unsigned long curr = (unsigned long)current;  unsigned long zero = 0UL;
  if (atomic_long_try_cmpxchg_acquire(&lock->owner, &zero, curr))    return true;
  return false;}

可以看到加鎖時先嘗試直接加鎖，用的就是CAS原子指令(x86的CAS指令叫做cmpxchg)。如果owner是0，代表當前鎖是開著的，就把owner設(shè)置為自己(也就是當前線程，struct task_struct * 強轉(zhuǎn)為 ulong)，代表自己成為這個鎖的主人，也就是自己加鎖成功了，然后返回true。如果owner不為0的話，代表有人已經(jīng)持有鎖了，返回false，后面就要走慢速路徑了，也就是把自己放入等待隊列里休眠等待。下面看看慢速路徑的代碼是怎么實現(xiàn)的：

static noinline void __sched__mutex_lock_slowpath(struct mutex *lock){  __mutex_lock(lock, TASK_UNINTERRUPTIBLE, 0, NULL, _RET_IP_);}
static int __sched__mutex_lock(struct mutex *lock, unsigned int state, unsigned int subclass,       struct lockdep_map *nest_lock, unsigned long ip){  return __mutex_lock_common(lock, state, subclass, nest_lock, ip, NULL, false);}
static __always_inline int __sched__mutex_lock_common(struct mutex *lock, unsigned int state, unsigned int subclass,        struct lockdep_map *nest_lock, unsigned long ip,        struct ww_acquire_ctx *ww_ctx, const bool use_ww_ctx){  struct mutex_waiter waiter;  int ret;
  raw_spin_lock(&lock->wait_lock);  waiter.task = current;  __mutex_add_waiter(lock, &waiter, &lock->wait_list);
  set_current_state(state);  for (;;) {    bool first;    if (__mutex_trylock(lock))      goto acquired;
    raw_spin_unlock(&lock->wait_lock);    schedule_preempt_disabled();
    first = __mutex_waiter_is_first(lock, &waiter);    set_current_state(state);    if (__mutex_trylock_or_handoff(lock, first))      break;
    raw_spin_lock(&lock->wait_lock);  }
acquired:  __set_current_state(TASK_RUNNING);  __mutex_remove_waiter(lock, &waiter);  raw_spin_unlock(&lock->wait_lock);
  return ret;}
static void__mutex_add_waiter(struct mutex *lock, struct mutex_waiter *waiter,       struct list_head *list){  debug_mutex_add_waiter(lock, waiter, current);
  list_add_tail(&waiter->list, list);  if (__mutex_waiter_is_first(lock, waiter))    __mutex_set_flag(lock, MUTEX_FLAG_WAITERS);}

可以看到慢速路徑最終會調(diào)用函數(shù)__mutex_lock_common，這個函數(shù)本身是很復雜的，這里進行了大量的刪減，只保留了核心邏輯。函數(shù)先加鎖mutex的自旋鎖，然后把自己放到等待隊列上去，然后就在無限for循環(huán)中休眠并等待別人釋放鎖并喚醒自己。For循環(huán)的入口處先嘗試加鎖，如果成功就goto acquired，如果不成功就釋放自旋鎖，并調(diào)用schedule_preempt_disabled，此函數(shù)就是休眠函數(shù)，它會調(diào)度其它進程來執(zhí)行，自己就休眠了，直到有人喚醒自己才會醒來繼續(xù)執(zhí)行。別人釋放鎖的時候會喚醒自己，這個我們后面會分析。當我們被喚醒之后會去嘗試加鎖，如果加鎖失敗，再次來到for循環(huán)的開頭處，再試一次加鎖，如果不行就再走一次休眠過程。為什么我們加鎖會失敗呢，因為有可能多個線程同時被喚醒來爭奪鎖，我們不一定會搶鎖成功。搶鎖失敗就再去休眠，最后總會搶鎖成功的。

把自己加入等待隊列時會設(shè)置flag MUTEX_FLAG_WAITERS，這個flag是設(shè)置在owner的低位上去，因為task_struct指針至少是L1_CACHE_BYTES對齊的，所以最少有3位可以空出來做flag。

下面我們再來看一下釋放鎖的流程：

void __sched mutex_unlock(struct mutex *lock){  if (__mutex_unlock_fast(lock))    return;  __mutex_unlock_slowpath(lock, _RET_IP_);}
static __always_inline bool __mutex_unlock_fast(struct mutex *lock){  unsigned long curr = (unsigned long)current;
  return atomic_long_try_cmpxchg_release(&lock->owner, &curr, 0UL);}

解鎖的時候先嘗試快速解鎖，快速解鎖的意思是沒有其它在等待隊列里，可以直接釋放鎖。怎么判斷等待隊列里沒有線程在等待呢，這就是前面設(shè)置的MUTEX_FLAG_WAITERS的作用了。如果設(shè)置了這個flag，lock->owner 和 curr就不會相等，直接釋放鎖就會失敗，就要走慢速路徑。慢速路徑的代碼如下：

static noinline void __sched __mutex_unlock_slowpath(struct mutex *lock, unsigned long ip){  struct task_struct *next = NULL;  DEFINE_WAKE_Q(wake_q);  unsigned long owner;
  owner = atomic_long_read(&lock->owner);  for (;;) {    if (atomic_long_try_cmpxchg_release(&lock->owner, &owner, __owner_flags(owner))) {      if (owner & MUTEX_FLAG_WAITERS)        break;    }  }
  raw_spin_lock(&lock->wait_lock);  if (!list_empty(&lock->wait_list)) {    struct mutex_waiter *waiter =      list_first_entry(&lock->wait_list,           struct mutex_waiter, list);    next = waiter->task;    wake_q_add(&wake_q, next);  }  raw_spin_unlock(&lock->wait_lock);  wake_up_q(&wake_q);}

上述代碼進行了一些刪減。可以看出上述代碼會先釋放鎖，然后喚醒等待隊列里面的第一個等待者。

4.4 信號量

信號量與互斥鎖有很大的不同，互斥鎖代表只有一個線程能同時進入臨界區(qū)，而信號量是個整數(shù)計數(shù)，代表著某一類資源有多少個，能同時讓多少個線程訪問這類資源。信號量也沒有加鎖解鎖操作，信號量類似的操作叫做down和up，down代表獲取一個資源，up代表歸還一個資源。

下面我們先看一下信號量的定義：

struct semaphore {  raw_spinlock_t    lock;  unsigned int    count;  struct list_head  wait_list;};
#define __SEMAPHORE_INITIALIZER(name, n)        {                    .lock    = __RAW_SPIN_LOCK_UNLOCKED((name).lock),    .count    = n,              .wait_list  = LIST_HEAD_INIT((name).wait_list),    }
static inline void sema_init(struct semaphore *sem, int val){  *sem = (struct semaphore) __SEMAPHORE_INITIALIZER(*sem, val);}

可以看出信號量和互斥鎖的定義很相似，都有一個自旋鎖，一個等待隊列，不同的是信號量沒有owner，取而代之的是count，代表著某一類資源的個數(shù)，而且自旋鎖同時保護著等待隊列和count。信號量初始化時要指定count的大小。

我們來看一下信號量的down操作(獲取一個資源)：

void down(struct semaphore *sem){  unsigned long flags;
  might_sleep();  raw_spin_lock_irqsave(&sem->lock, flags);  if (likely(sem->count > 0))    sem->count--;  else    __down(sem);  raw_spin_unlock_irqrestore(&sem->lock, flags);}
static noinline void __sched __down(struct semaphore *sem){  __down_common(sem, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);}
static inline int __sched __down_common(struct semaphore *sem, long state,                long timeout){  struct semaphore_waiter waiter;
  list_add_tail(&waiter.list, &sem->wait_list);  waiter.task = current;  waiter.up = false;
  for (;;) {    if (signal_pending_state(state, current))      goto interrupted;    if (unlikely(timeout <= 0))      goto timed_out;    __set_current_state(state);    raw_spin_unlock_irq(&sem->lock);    timeout = schedule_timeout(timeout);    raw_spin_lock_irq(&sem->lock);    if (waiter.up)      return 0;  }
 timed_out:  list_del(&waiter.list);  return -ETIME;
 interrupted:  list_del(&waiter.list);  return -EINTR;}

可以看出我們會先持有自旋鎖，然后看看count是不是大于0，大于0的話代表資源還有剩余，我們直接減1，代表占用一份資源，就可以返回了。如果不大于0的話，代表資源沒有了，我們就進去等待隊列等待。

我們再來看看up操作(歸還資源)：

void up(struct semaphore *sem){  unsigned long flags;
  raw_spin_lock_irqsave(&sem->lock, flags);  if (likely(list_empty(&sem->wait_list)))    sem->count++;  else    __up(sem);  raw_spin_unlock_irqrestore(&sem->lock, flags);}
static noinline void __sched __up(struct semaphore *sem){  struct semaphore_waiter *waiter = list_first_entry(&sem->wait_list,            struct semaphore_waiter, list);  list_del(&waiter->list);  waiter->up = true;  wake_up_process(waiter->task);}

先加鎖自旋鎖，然后看看等待隊列是否為空，如果為空的話直接把count加1就可以了。如果不為空的話，則代表有人在等待資源，資源就不加1了，直接喚醒隊首的線程來獲取。

?

?五、per-CPU變量 ? ?前面講的原子操作和加鎖機制都是從時間上防同步的，現(xiàn)在我們開始講空間上防同步，先來講講per-CPU變量。如果我們要操作的數(shù)據(jù)和當前CPU是密切相關(guān)的，不同的CPU可以操作不同的數(shù)據(jù)，那么我們就可以把這個變量定義為per-CPU變量，每個CPU就可以各訪問各的，互不影響了。這個方法可以防止多個CPU之間的真并發(fā)，但是同一個CPU上如果有偽并發(fā)，還是會出問題，所以還需要禁用偽并發(fā)。per-CPU變量的定義和使用方法如下表所示：

Macro or function name	Description
DEFINE_PER_CPU(type, name)	Statically allocates a per-CPU array called name of type data structures
per_cpu(name, cpu)	Selects the element for CPU cpu of the per-CPU array name
_ _get_cpu_var(name)	Selects the local CPU’s element of the per-CPU array name
get_cpu_var(name)	Disables kernel preemption, then selects the local CPU’s element of the per-CPU array name
put_cpu_var(name)	Enables kernel preemption (name is not used)
alloc_percpu(type)	Dynamically allocates a per-CPU array of type data structures and returns its address
free_percpu(pointer)	Releases a dynamically allocated per-CPU array at address pointer
per_cpu_ptr(pointer, cpu)	Returns the address of the element for CPU cpu of the per-CPU array at address pointer

?

?六、RCU簡介 ? ?RCU是一種非常巧妙的空間防同步方法。首先它只能用于用指針訪問的動態(tài)數(shù)據(jù)。其次它采取讀者和寫者分開的方法，讀者讀取數(shù)據(jù)要先復制指針，用這個復制的指針來訪問數(shù)據(jù)，這個數(shù)據(jù)是只讀的，不會被修改，很多讀者可以同時來訪問。寫者并不去直接更改數(shù)據(jù)，而是先申請一塊內(nèi)存空間，把數(shù)據(jù)都復制過來，在這個復制的數(shù)據(jù)上修改數(shù)據(jù)，由于這塊數(shù)據(jù)是私有的，所以可以隨意修改，也不用加鎖。修改完了之后，寫者要原子的修改指針的值，讓它指向自己新完成的數(shù)據(jù)。這對于讀者來說是沒有影響的，因為讀者已經(jīng)復制了指針，所以讀者讀的還是原來的數(shù)據(jù)沒有變，新來的讀者會復制新的指針，訪問新的數(shù)據(jù)，讀者訪問的一直都是一致性的數(shù)據(jù)，不會訪問到修改一半的數(shù)據(jù)。RCU的難點在于，原有的數(shù)據(jù)怎么回收，當寫者更新指針之后，原先的數(shù)據(jù)就過期了，當所有老的讀者都離開臨界區(qū)之后，這個數(shù)據(jù)的內(nèi)存需要被釋放，寫者需要判斷啥時候老的讀者全都離開臨界區(qū)了，才能去釋放老的數(shù)據(jù)。

?

?七、序列鎖 ? ?除了前面講的時間防同步、空間防同步，Linux還有一種非常巧妙的防同步方法，那就是不妨了事后再補救，我第一次看到這個方法的時候，真是拍案叫絕，驚嘆不已，還能這么做。這種方法叫做序列鎖，它的思想就好比是，我家里也不鎖門了，小偷偷就偷吧，偷了我就再報警把東西找回來。反正小偷又不是天天來我家偷東西，小偷來的次數(shù)非常少，我天天鎖門太費勁了。我每天早上看一下啥東西丟了沒，丟了就報警把東西找回來。當然這個類比并不完全像，只是大概邏輯比較像，下面我們就來講一講序列鎖的做法。序列鎖區(qū)分讀者和寫者，讀者可以并行，寫者還是需要互斥的，讀者和寫者之間也可以并行，所以當讀者很頻繁，寫者很偶發(fā)的時候就適合用序列鎖。這個鎖有一個序列號，初始值是0，寫者進入臨界區(qū)時把這個序列號加1，退出時再加1，讀者讀之前先獲取這個鎖的序列號，如果是奇數(shù)說明有寫者在臨界區(qū)，就不停地獲取序列號，直到序列號為偶數(shù)為止。然后讀者進入臨界區(qū)進行讀操作，然后退出臨界區(qū)的時候再讀取一下序列號。如果和剛才獲取的序列號不一樣，說明有寫者剛才進來過，再重新走一遍剛才的操作。如果序列號還不一樣就一直重復，直到序列號一樣為止。

下面我們先來看看序列鎖的定義：

typedef struct seqcount {  unsigned sequence;} seqcount_t;
typedef struct {  seqcount_spinlock_t seqcount;  spinlock_t lock;}?seqlock_t;

seqlock_t包含一個自旋鎖和一個seqcount_spinlock_t，seqcount_spinlock_t經(jīng)過一些復雜的宏定義包含了seqcount_t，所以可以簡單地認為seqlock_t包含一個自旋鎖和一個int序列號。

下面我們看一下寫者的操作：

 #include pid_t?fork(void);

寫者的操作很簡單，就是用自旋鎖實現(xiàn)互斥，然后加鎖解釋的時候都把序列號增加1。

下面看讀者的操作：

static inline void write_seqlock(seqlock_t *sl){  spin_lock(&sl->lock);  do_write_seqcount_begin(&sl->seqcount.seqcount);}
static inline void write_sequnlock(seqlock_t *sl){  do_write_seqcount_end(&sl->seqcount.seqcount);  spin_unlock(&sl->lock);}

讀者進入臨界區(qū)之前先通過read_seqbegin獲取一個序列號，在臨界區(qū)的時候調(diào)用read_seqretry看看是否需要重走一遍臨界區(qū)。我們下面看一下內(nèi)核里使用序列鎖的一個例子：

static inline unsigned read_seqbegin(const seqlock_t *sl){  unsigned ret = read_seqcount_begin(&sl->seqcount);
  kcsan_atomic_next(0);  /* non-raw usage, assume closing read_seqretry() */  kcsan_flat_atomic_begin();  return ret;}
static inline unsigned read_seqretry(const seqlock_t *sl, unsigned start){  /*   * Assume not nested: read_seqretry() may be called multiple times when   * completing read critical section.   */  kcsan_flat_atomic_end();
  return read_seqcount_retry(&sl->seqcount, start);}

可以看到寫者使用序列鎖和正常的使用方法是一樣的，讀者使用序列鎖一般都是配合do while循環(huán)一起使用。

通過本文，我們明白了線程同步的本質(zhì)，了解了線程防同步的基本邏輯和具體方法。防同步就是防止多個執(zhí)行流同時訪問相同的數(shù)據(jù)，所以我們可以從兩點來防，一個是同時(時間上防同步)，一個是相同的數(shù)據(jù)(空間上防同步)。時間上防同步我們采取的方法有原子操作，通過硬件來防止同時，加鎖機制，軟件方法來防同時，還有禁用偽并發(fā)，防止宏觀上的同時微觀上的交錯?？臻g防同步我們采取的方法有數(shù)據(jù)分割、per CPU變量，每個CPU值訪問自己對應(yīng)的數(shù)據(jù)。數(shù)據(jù)復制，RCU，讀的時候復制指針，讀的數(shù)據(jù)是不變的，寫的時候不直接改變數(shù)據(jù)，而是先把數(shù)據(jù)復制過來，修改自己的私有副本，這樣就不會有同步的問題，然后再原子地更新指針指向最新的數(shù)據(jù)。

?

?八、總結(jié)回顧 ? ?通過本文，我們明白了線程同步的本質(zhì)，了解了線程防同步的基本邏輯和具體方法。防同步就是防止多個執(zhí)行流同時訪問相同的數(shù)據(jù)，所以我們可以從兩點來防，一個是同時(時間上防同步)，一個是相同的數(shù)據(jù)(空間上防同步)。時間上防同步我們采取的方法有原子操作，通過硬件來防止同時，加鎖機制，軟件方法來防同時，還有禁用偽并發(fā)，防止宏觀上的同時微觀上的交錯。空間防同步我們采取的方法有數(shù)據(jù)分割、per CPU變量，每個CPU值訪問自己對應(yīng)的數(shù)據(jù)。數(shù)據(jù)復制，RCU，讀的時候復制指針，讀的數(shù)據(jù)是不變的，寫的時候不直接改變數(shù)據(jù)，而是先把數(shù)據(jù)復制過來，修改自己的私有副本，這樣就不會有同步的問題，然后再原子地更新指針指向最新的數(shù)據(jù)。

　　審核編輯：湯梓紅

閱讀全文

內(nèi)核(39814) 內(nèi)核(39814)
Linux(206513) Linux(206513)
線程(19463) 線程(19463)

Linux下線程編程

Linux下線程編程

2022-08-24 15:42:45

1682

Linux開發(fā)_采用線程處理網(wǎng)絡(luò)請求

介紹Linux下網(wǎng)絡(luò)編程、線程編程，select機制，利用子線程響應(yīng)TCP服務(wù)器的請求。

2022-09-17 15:21:27

634

Linux中進程和線程的深度對比

關(guān)于進程和線程，在 Linux 中是一對兒很核心的概念。但是進程和線程到底有啥聯(lián)系，又有啥區(qū)別，很多人還都沒有搞清楚。

2022-10-14 16:47:29

1026

Linux系統(tǒng)中線程同步方式中的條件變量方法

今天主要和大家聊一聊，如何使用Linux中線程同步方式中的條件變量。

2022-11-08 09:16:13

417

Linux Shell腳本入門到實戰(zhàn)詳解

Linux Shell腳本入門到實戰(zhàn)詳解

2023-02-17 15:03:51

455

Linux LED子系統(tǒng)詳解

Linux LED子系統(tǒng)詳解

2023-06-10 10:37:14

945

Linux內(nèi)核同步機制mutex詳解

在linux內(nèi)核中，互斥量mutex是一種保證CPU串行運行的睡眠鎖機制。和spinlock類似，都是同一個時刻只有一個線程進入臨界資源，不同的是，當無法獲取鎖的時候，spinlock原地自旋，而mutex則是選擇掛起當前線程，進入阻塞狀態(tài)。所以，mutex無法在中斷上下文中使用。

2023-06-26 16:05:58

498

Linux多線程編程基礎(chǔ)知識解析

線程是輕量級的進程(`LWP: Light Weight Process`)，在`Linux`環(huán)境下線程的本質(zhì)仍是`進程`，進程是資源分配的`最小單位`，線程是操作系統(tǒng)調(diào)度執(zhí)行的`最小單位`。

2023-07-14 16:41:43

450

Linux c多線程編程的4個實例

的內(nèi)存空間的?！　?b class="flag-6" style="color: red">Linux也不例外，雖然從內(nèi)核的角度來看，線程體現(xiàn)為一種對進程的"克隆"(clone),共享進程的資源。但是在用戶空間提供了線程管理機制來實現(xiàn)對線程的管理，目前

2018-10-17 09:32:16

Linux c多線程編程的4個實例分享

Linux c多線程編程的4個實例　　在主流的操作系統(tǒng)中，多任務(wù)一般都提供了進程和線程兩種實現(xiàn)方式，進程享有獨立的進程空間，而線程相對于進程來說是一種更加輕量級的多任務(wù)并行，多線程之間一般都是共享

2020-06-09 04:35:40

Linux線程實現(xiàn)與線程控制步驟簡析

線程共享了進程的資源和地址空間，因此，任何線程對系統(tǒng)資源的操作都會給其他線程帶來影響，因此，多線程中的同步就是非常重要的問題了。在多線程系統(tǒng)中，進程與線程的關(guān)系如表 8.1 所示。Linux線程實現(xiàn)1．

2022-04-25 09:29:35

Linux下多線程機制

另一個帶類型的指針變量線程的同步與互斥同步(按照預想的順序執(zhí)行)M->Y->M->Y->M->YM->YYY->M->YYY......互斥你用，我不能

2016-11-11 09:53:39

Linux下的線程安全是什么

數(shù)據(jù)二義性。同步與互斥：同步：通過條件判斷，實現(xiàn)對靈界資源訪問的時序合理性?；コ猓和ㄟ^唯一訪問，實現(xiàn)對臨界資源的安全性。一、互斥實現(xiàn)的技術(shù)：互斥鎖原理：保證同一時間只有一個執(zhí)行流對臨界資源進行訪問。即：對臨界資源進行標記，無訪問時標記為1，有訪問時標記為0，當標記為1時，則用戶可訪問或線程

2021-07-01 13:34:52

Linux多線程及線程間同步

。同一進程內(nèi)的線程共享進程的地址空間。通信：進程間通信IPC，線程間可以直接讀寫進程數(shù)據(jù)段（如全局變量）來進行通信——需要進程同步和互斥手段的輔助，以保證數(shù)據(jù)的一致性。調(diào)度和切換：線程上下文切換比進程

2017-12-08 14:14:06

Linux多線程編程手冊

Linux多線程編程手冊

2016-11-07 10:17:40

Linux的線程同步方法

Linux下提供了多種方式來處理線程同步，最常用的是互斥鎖、條件變量和信號量。

2019-07-19 07:24:51

Linux的chattr與lsattr命令詳解

【轉(zhuǎn)】Linux的chattr與lsattr命令詳解

2020-04-20 11:38:20

Linux的進程、線程以及調(diào)度

報名：《Linux的進程、線程以及調(diào)度》4節(jié)系列微課(522-25)

2020-05-15 14:44:24

Linux系統(tǒng)的線程到底是什么

在嵌入式操作系統(tǒng)中，任務(wù)相當于Linux系統(tǒng)的線程。在所有的操作系統(tǒng)中，線程（在嵌入式操作系統(tǒng)中一般稱為任務(wù)）是一個單一順序的執(zhí)行流，是分配運行資源（CPU的運行時間）的基本單位。操作系統(tǒng)根據(jù)一

2021-12-21 07:27:55

Linux設(shè)備驅(qū)動開發(fā)詳解

#《Linux設(shè)備驅(qū)動開發(fā)詳解》電子書連載#第7章 Linux設(shè)備驅(qū)動中的并發(fā)控制，Linux設(shè)備驅(qū)動中必須解決的一個問題是多個進程對共享資源的并發(fā)訪問，并發(fā)訪問會導致競態(tài)。Linux提供了多種解決競態(tài)問題的方式，這些方式適合不同的應(yīng)用場景。詳情：http://t.cn/zHONW9I

2013-06-09 14:48:50

Linux設(shè)備驅(qū)動開發(fā)詳解：基于最新的Linux 4.0內(nèi)核

Linux設(shè)備驅(qū)動開發(fā)詳解：基于最新的Linux 4.0內(nèi)核

2019-08-31 12:29:13

Linux進程和線程的區(qū)別是什么？

Linux進程和線程的區(qū)別是什么為什么要使用線程？線程操作的函數(shù)

2021-03-11 06:13:59

linux 下如何獲取線程ID

linux多線程環(huán)境下gettid() pthread_self() 兩個函數(shù)都獲得線程ID，但這2個ID有所不同gettid是內(nèi)核中的線程的ID：POSIX thread ID可以在一個進程內(nèi)唯一

2019-07-09 08:36:48

linux線程同步方法

最近研究mysql源碼，各種鎖，各種互斥，好在我去年認真學了《unix環(huán)境高級編程》，雖然已經(jīng)忘得差不多了，但是學過始終是學過，拿起來也快。寫這篇文章的目的就是總結(jié)linux 下多線程編程，作為日后的參考資料。

2019-08-06 06:15:28

linux多線程常用相關(guān)函數(shù)簡介

*arg) 用法：#include 功能：pthread_create是類Unix操作系統(tǒng)（Unix、Linux、Mac OS X等）的創(chuàng)建線程的函數(shù) 說明：函數(shù)若線程創(chuàng)建成功，則返回0，若線程創(chuàng)建失敗

2018-06-27 08:36:01

linux的線程狀態(tài)怎么查看

在linux下運行多線程程序，想查看各個線程的運行情況，怎么辦？

2019-07-22 07:27:33

linux系統(tǒng)中管道的介紹和線程同步代碼示例

傳統(tǒng)的進程間通信其中有無名管道(PIPE)、有名管道(FIFO)和信號(Signal)。咱們今天就說說linux中基于POSIX的有名管道(FIFO)和無名管道(PIPE)。1. 描述：管道提供一個

2016-10-06 09:55:21

linux設(shè)備樹詳解

linux設(shè)備樹詳解 2003 年畢業(yè)于中國科學技術(shù)大學，電子專業(yè)、軟件專業(yè)...

2021-12-23 08:16:32

一文詳解linux線程

linux線程全解-linux應(yīng)用編程和網(wǎng)絡(luò)編程第7部分互聯(lián)網(wǎng)課程品牌《朱...

2021-12-23 06:07:24

一文詳解linux下system()函數(shù)

對于linux下system()函數(shù)的深度理解

2021-02-02 06:09:32

一文簡介線程

按照規(guī)劃，從本篇開始我們開啟『并發(fā)』系列內(nèi)容的總結(jié)，從本篇的線程開始，到線程池，到幾種并發(fā)集合源碼的分析，我們一點點來，希望你也有耐心，因為并發(fā)這塊知識是你職業(yè)生涯始終繞不過的坎，任何一個項目都

2020-10-25 16:22:50

線程同步管理是什么意思

IPC對象控制塊包括哪些？線程同步管理是什么意思？

2021-09-30 08:28:35

線程的同步方式有哪幾種？

2021-05-26 07:13:07

詳解Linux線程

最近在重新翻閱《Unix環(huán)境高級編程》的時候，被書上的一段例程所困擾，那段代碼是分別在主線程和子線程中使用 getpid() 函數(shù)打印進程標識符PID，書上告訴我們是不同的值，但是測試結(jié)果是主線程和子線程中打印出了相同的值。

2019-08-05 06:32:51

詳解線程狀態(tài)中 sp 的含義

詳解 sp 含義最近使用 RT-Thread 的 Finsh 輸入 list_thread 命令查看線程狀態(tài)時，突然注意到多個線程在 sp 這一項內(nèi)容上竟然是相同的，如下所示：thread pri

2022-06-29 11:03:10

ARM嵌入式Linux系統(tǒng)開發(fā)詳解

建立和第一個Linux應(yīng)用程序；第2篇介紹了Linux應(yīng)用程序編程基礎(chǔ)、開發(fā)多進程/線程程序、網(wǎng)絡(luò)通信應(yīng)用、串行口通信編程、嵌入式GUI程序開發(fā)和軟件項目管理；第3篇介紹ARM體系結(jié)構(gòu)及開發(fā)實例、深入

2018-09-14 08:57:17

FAT32文件系統(tǒng)詳解

2016-08-17 12:34:56

Mini Linux

Mini Linux EMMC

2023-03-28 13:06:25

NE555中文資料詳解

2012-08-20 13:49:07

NE555中文資料詳解

2012-08-21 09:27:19

NE555中文資料詳解

2012-11-23 22:08:18

i.MX6ULL開發(fā)板線程同步POSIX無名信號量

為保證每個線程對同一資源訪問有效，比如一個線程想要從共享資源讀數(shù)據(jù)，而這些資源正在被其他線程修改，那么讀出來的數(shù)據(jù)是無效的，那么就要想辦法讓其他線程修改完再去讀，這時候就用到了同步機制?？梢?/div>

2021-04-02 14:04:09

【Linux學習雜談】之線程同步

，兩個是一樣的，不加以區(qū)分。那么一般信號量一般是用于同步使用的，舉個簡單的例子就是說我們兩者要同步，那么我們一般是怎么樣，其中一個人說123開始，然后同時開始做某件事情，那么從進程和線程上面來講也是這樣

2016-10-21 19:12:12

為什么使用事件通知線程同步會導致線程死掉呢？

使用事件通知線程同步，導致線程死掉，而且使用ps命令，系統(tǒng)直接出錯死掉代碼如下static void fin_timer_handler(void *args)//這個是中斷的下半部，使用的軟件定時器{ rt_event_send(&event, EVENT_PRESS_FR);//

2023-03-14 10:32:39

多線程同步和互斥有幾種實現(xiàn)方法

線程同步是指線程之間所具有的一種制約關(guān)系，一個線程的執(zhí)行依賴另一個線程的消息，當它沒有得到另一個線程的消息時應(yīng)等待，直到消息到達時才被喚醒。線程互斥是指對于共享的進程系統(tǒng)資源，在各單個線程訪問時的排

2019-08-05 06:06:39

多線程編程之四線程的同步

響應(yīng)儲戶的需要，極有可能讀數(shù)據(jù)庫的線程讀取的是未完全更新的數(shù)據(jù)庫，因為可能在讀的時候只有一部分數(shù)據(jù)被更新過?！　∈闺`屬于同一進程的各線程協(xié)調(diào)一致地工作稱為線程的同步。MFC提供了多種同步對象，下面我們

2008-10-22 11:43:42

嵌入式Linux多線程編程

嵌入式Linux多線程編程-學習資源-華清遠見清遠見嵌入式學院：清遠見嵌入式學院：《嵌入式應(yīng)用程序設(shè)計》——第5 章嵌入式Linux 多線程編程第5 章嵌入式Linux 多線程編程本章

2021-11-05 06:54:35

淺析Linux線程概念

首先Linux并不存在真正的線程，Linux的線程是使用進程模擬的。當我們需要在一個進程中同時運行多個執(zhí)行流時，我們并不可以開辟多個進程執(zhí)行我們的操作（32位機器里每個進程認為它獨享 4G的內(nèi)存

2019-07-23 06:10:56

淺談基于Linux操作系統(tǒng)中多線程的同步原理及應(yīng)用

。這些線程將重新鎖定互斥鎖并重新測試條件是否滿足。一般說來，條件變量被用來進行線程間的同步?！　l件變量的結(jié)構(gòu)為pthread_cond_t，函數(shù)pthread_cond_init()被用來初始化一個

2012-02-02 14:49:46

高效輕型線程對Linux實時性能有什么影響

(light-weight threading, LWT) 即可。我們來研究一下實時 Linux，以及輕型線程如何能成為適用于某些應(yīng)用的解決方案。研究的重點受電信、網(wǎng)絡(luò)或常用通信應(yīng)用的影響，Enea側(cè)重于這些應(yīng)用中采用的技術(shù)。但總體上來說，對輕型線程的重點應(yīng)用會使多方受益。

2019-05-16 10:45:05

Linux關(guān)機命令詳解

Linux關(guān)機命令詳解在linux下一些常用的關(guān)機/重啟命令有shutdown、halt、reboot、及init，它們都可以達到重啟系統(tǒng)的目的，但每個命令的內(nèi)部工作過程是不同的，通過本

2009-01-18 12:52:27

3499

linux多線程編程課件

電子發(fā)燒友為您提供了linux多線程編程課件，希望對您學習 linux 有所幫助。部分內(nèi)容如下： *1、多線程模型在單處理器模型和多處理器系統(tǒng)上，都能改善響應(yīng)時間和吞吐量。 *2、線程包

2011-07-10 11:58:43

Linux多線程同步方法

在線程對共享相同內(nèi)存操作時，就會出現(xiàn)多個線程對同一資源的使用，為此，需要對這些線程進行同步，以確保它們在訪問共享內(nèi)存的時候不會訪問到無效的數(shù)值。

2011-08-08 14:17:16

1946

linux多線程編程開發(fā)

本文中我們針對 Linux 上多線程編程的主要特性總結(jié)出 5 條經(jīng)驗，用以改善 Linux 多線程編程的習慣和避免其中的開發(fā)陷阱。在本文中，我們穿插一些 Windows 的編程用例用以對比 Linux 特性

2011-12-26 14:24:44

linux核心技術(shù)詳解

很好的一本Linux技術(shù)詳解，值得一讀。

2015-11-09 17:35:42

Linux網(wǎng)絡(luò)編程實例詳解

網(wǎng)絡(luò)通訊教程學習之Linux網(wǎng)絡(luò)編程實例詳解

2016-09-01 14:55:49

VC-MFC多線程編程詳解

VC編程中關(guān)于 MFC多線程編程的詳解文檔

2016-09-01 15:01:52

linux下網(wǎng)卡配置詳解

linux下網(wǎng)卡配置詳解

2016-12-15 22:38:51

Linux下多線程的視頻圖像平滑度評價算法_饒鴻

Linux下多線程的視頻圖像平滑度評價算法_饒鴻

2017-03-19 11:27:34

java多線程同步方法

二、為什么要線程同步因為當我們有多個線程要同時訪問一個變量或?qū)ο髸r，如果這些線程中既有讀又有寫操作時，就會導致變量值或?qū)ο蟮臓顟B(tài)出現(xiàn)混亂，從而導致程序異常。舉個例子，如果一個銀行賬戶同時被兩個線程

2017-09-27 13:19:40

多線程編程之Linux線程編程

9.2 Linux線程編程 9.2.1 線程基本編程這里要講的線程相關(guān)操作都是用戶空間中的線程的操作。在Linux中，一般pthread線程庫是一套通用的線程庫，是由POSIX提出的，因此具有很好

2017-10-18 15:55:26

linux多線程編程技術(shù)

（process）中只允許有一個線程，這樣多線程就意味著多進程?，F(xiàn)在，多線程技術(shù)已經(jīng)被許多操作系統(tǒng)所支持，包括Windows/NT，當然，也包括Linux。為什么有了進程的概念后，還要再引入線程呢？使用多線程到底有哪些好處？什么的系統(tǒng)應(yīng)該選用多線程？我們首先必須回答這些問題。使

2017-10-24 16:01:39

基于嵌入式Linux應(yīng)用程序開發(fā)詳解

基于嵌入式Linux應(yīng)用程序開發(fā)詳解

2017-10-25 14:17:31

《Linux設(shè)備驅(qū)動開發(fā)詳解》第23章、Linux設(shè)備驅(qū)動的移植

《Linux設(shè)備驅(qū)動開發(fā)詳解》第23章、Linux設(shè)備驅(qū)動的移植

2017-10-27 10:58:13

《Linux設(shè)備驅(qū)動開發(fā)詳解》第13章、Linux塊設(shè)備驅(qū)動

《Linux設(shè)備驅(qū)動開發(fā)詳解》第13章、Linux塊設(shè)備驅(qū)動

2017-10-27 11:24:39

《Linux設(shè)備驅(qū)動開發(fā)詳解》第7章、Linux設(shè)備驅(qū)動中的并發(fā)控制

《Linux設(shè)備驅(qū)動開發(fā)詳解》第7章、Linux設(shè)備驅(qū)動中的并發(fā)控制

2017-10-27 11:37:45

《Linux設(shè)備驅(qū)動開發(fā)詳解》第4章、Linux內(nèi)核模塊

《Linux設(shè)備驅(qū)動開發(fā)詳解》第4章、Linux內(nèi)核模塊

2017-10-27 14:15:51

詳解嵌入式linux 啟動信息

詳解嵌入式linux 啟動信息

2017-10-30 10:28:02

Linux和Windows系統(tǒng)線程間的區(qū)別

熟悉WIN32編程的人一定知道，WIN32的進程管理方式與Linux上有著很大區(qū)別，在Unix里，只有進程的概念，但在WIN32里卻還有一個線程的概念，那么Linux和WIN32在這里究竟

2017-11-03 12:37:25

各型號的DSPBIOS線程同步原語以及相關(guān)的問題和約束

DSP編程已經(jīng)從單循環(huán)程序過渡到使用實時特征的復雜多線程應(yīng)用程序。多線程應(yīng)用程序需要同步對共享資源的訪問。 DSP/BIOS提供了同步線程的多個機制。該機制提供了禁用線程類型、更改線程優(yōu)先級以及

2018-05-03 09:24:55

了解Linux多線程及線程間同步

進程間通信IPC，線程間可以直接讀寫進程數(shù)據(jù)段（如全局變量）來進行通信——需要進程同步和互斥手段的輔助，以保證數(shù)據(jù)的一致性。

2019-04-23 14:23:01

605

linux syscall系統(tǒng)調(diào)用獲取線程PID

Linux中，每個進程有一個pid，類型pid_t，由getpid()取得。Linux下的POSIX線程也有一個id，類型 pthread_t，由pthread_self()取得，該id由線程庫維護，其id空間是各個進程獨立的（即不同進程中的線程可能有相同的id）。

2019-04-26 15:46:01

988

Linux--線程編程

變量放在線程控制表內(nèi)　　一個進程可以有多個線程，有多個線程控制表及堆棧寄存器，共享一個用戶地址空間?多線程同步問題　　線程共享進程的資源和地址空間　　任何線程對系統(tǒng)資源的操作都會給其他線程帶來

2019-04-02 14:40:20

183

linux多線程機制-線程同步

,線程調(diào)度、同步與互斥都需要用戶程序自己完成。內(nèi)核級線程需要內(nèi)核參與,由內(nèi)核完成線程調(diào)度并提供相應(yīng)的系統(tǒng)調(diào)用,用戶程序可以通過這些接口函數(shù)對線程進行一定的控制和管理。Linux操作系統(tǒng)提供

2019-04-02 14:42:43

329

Linux下的多線程編程

一個進程（process）中只允許有一個線程，這樣多線程就意味著多進程?，F(xiàn)在，多線程技術(shù)已經(jīng)被許多操作系統(tǒng)所支持，包括Windows/NT，當然，也包括Linux?！　槭裁从辛诉M程的概念后，還要再引入

2019-04-02 14:43:07

465

Linux多線程同步互斥量Mutex詳解

嵌入式linux中文站向各位愛好者介紹linux常見同步方式互斥量Mutex的使用方法1. 初始化：在Linux下, 線程的互斥量數(shù)據(jù)類型是pthread_mutex_t.

2019-04-02 14:45:08

225

linux線程淺析

關(guān)于linux線程在許多經(jīng)典的操作系統(tǒng)教科書中, 總是把進程定義為程序的執(zhí)行實例, 它并不執(zhí)行什么, 只是維護應(yīng)用程序所需的各種資源. 而線程則是真正的執(zhí)行實體.?為了讓進程完成一定

2019-04-02 14:45:10

198

Linux下C中怎么讓才能安全關(guān)閉線程

前言：? ? 多線程程序中，特別是頻繁申請，釋放線程的情況下，就要注意線程的關(guān)閉，最好使用線程池。一，線程退出方式? ? (1)?執(zhí)行完成后隱式退出；? ? (2)?由線程本身顯示

2019-04-02 14:45:18

605

Linux多線程與同步

典型的UNIX系統(tǒng)都支持一個進程創(chuàng)建多個線程(thread)。在Linux進程基礎(chǔ)中提到，Linux以進程為單位組織操作，Linux中的線程也都基于進程。盡管實現(xiàn)方式有異于其它

2019-04-02 14:47:58

316

linux下多線程的創(chuàng)建與等待詳解

成功返回0。當然，線程也不是被動的被別人結(jié)束。它可以通過設(shè)置自身的屬性來決定如何結(jié)束。線程的被動結(jié)束分為兩種，一種是異步終結(jié)，另外一種是同步終結(jié)。異步終結(jié)就是當其他線程調(diào)用 pthread_cancel

2019-04-02 14:48:01

230

三種Linux中的常用多線程同步方式淺析

嵌入式linux中文站給大家介紹三種Linux中的常用多線程同步方式：互斥量，條件變量，信號量。

2019-05-02 14:49:00

2873

虛擬機：查看linux線程的CPU占用率的方法

虛擬機：查看linux線程的CPU占用率的方法

2020-06-22 10:06:18

3818

虛擬機：linux 進程的最大線程個數(shù)

虛擬機：linux 進程的最大線程個數(shù)

2020-06-22 15:56:01

2423

虛擬機：Linux查看線程信息的步驟

虛擬機：Linux查看線程信息的步驟

2020-06-24 08:41:11

3210

Linux系統(tǒng)中EXP命令詳解質(zhì)量匯總

Linux系統(tǒng)中EXP命令詳解質(zhì)量匯總

2021-05-14 09:35:28

Linux虛擬機之tcpdump命令操作詳解

Linux虛擬機之tcpdump命令操作詳解

2021-08-12 09:50:11

嵌入式linux多線程編程實驗,嵌入式Linux多線程編程-學習資源-華清遠見.PDF

2021-11-02 13:36:16

MFC多線程及線程同步

MFC中有兩類線程，分別稱之為工作者線程和用戶界面線程。二者的主要區(qū)別在于工作者線程沒有消息循環(huán)，而用戶界面線程有自己的消息隊列和消息循環(huán)。

2022-06-01 17:03:38

Linux設(shè)備驅(qū)動開發(fā)詳解

Linux設(shè)備驅(qū)動開發(fā)詳解

2022-10-28 11:03:06

Linux和Windows系統(tǒng)中的線程同步

　　在現(xiàn)代操作系統(tǒng)中，每個進程都有自己的地址空間和一個控制線程。然而，在實踐中，我們經(jīng)常面臨需要在單個進程中執(zhí)行多個并發(fā)任務(wù)并訪問相同流程組件的情況：結(jié)構(gòu)、打開文件描述符等。

2022-11-30 15:13:55

447

RT-Thread文檔_線程間同步

2023-02-22 18:29:24

詳解Linux線程、線程與異步編程、協(xié)程與異步

協(xié)程不是系統(tǒng)級線程，很多時候協(xié)程被稱為“輕量級線程”、“微線程”、“纖程(fiber)”等。簡單來說可以認為協(xié)程是線程里不同的函數(shù)，這些函數(shù)之間可以相互快速切換。

2023-03-16 15:49:22

619

Linux中多線程編程的知識點

Hello、Hello大家好，我是木榮，今天我們繼續(xù)來聊一聊Linux中多線程編程中的重要知識點，詳細談?wù)劧?b class="flag-6" style="color: red">線程中同步和互斥機制。

2023-04-26 17:27:44

466

linux內(nèi)核線程就這樣誕生了么？

線程是操作系統(tǒng)的重要組成部件之一，linux內(nèi)核中，內(nèi)核線程是如何創(chuàng)建的，在內(nèi)核啟動過程中，誕生了哪些支撐整個系統(tǒng)運轉(zhuǎn)的線程，本文將帶著這個疑問瞅一瞅內(nèi)核源碼，分析內(nèi)核線程的創(chuàng)建機制。

2023-07-10 10:45:28

434

如何使用pthread_barrier_xxx系列函數(shù)來實現(xiàn)多線程之間的同步？

在Linux系統(tǒng)中提供了多種同步機制，本文主要講講如何使用pthread_barrier_xxx系列函數(shù)來實現(xiàn)多線程之間進行同步的方法。

2023-10-23 14:43:06

237

多線程同步的幾種方法

多線程同步是指在多個線程并發(fā)執(zhí)行的情況下，為了保證線程執(zhí)行的正確性和一致性，需要采用特定的方法來協(xié)調(diào)線程之間的執(zhí)行順序和共享資源的訪問。下面將介紹幾種常見的多線程同步方法。互斥鎖（Mutex

2023-11-17 14:16:19

412

多線程如何保證數(shù)據(jù)的同步

多線程編程是一種并發(fā)編程的方法，意味著程序中同時運行多個線程，每個線程可獨立執(zhí)行不同的任務(wù)，共享同一份數(shù)據(jù)。由于多線程并發(fā)執(zhí)行的特點，會引發(fā)數(shù)據(jù)同步的問題，即保證多個線程對共享數(shù)據(jù)的訪問順序和正確性

2023-11-17 14:22:09

240

linux多線程編程實例

linux線程

2024-02-15 21:16:35

已全部加載完成

搜索歷史

一文詳解Linux線程同步

?

?

?

?

?

?

?

?

評論