Linux 核心的同步機制，第 2 部分

六、大核心鎖（BKL--Big Kernel Lock）

大核心鎖本質上也是自旋鎖，但是它又不同於自旋鎖，自旋鎖是不可以遞迴獲得鎖的，因為那樣會導致死結。但大核心鎖可以遞迴獲得鎖。大核心鎖用於保護整個核心，而自旋鎖用於保護非常特定的某一共用資源。進程保持大核心鎖時可以發生調度，具體實現是：在執行schedule時，schedule將檢查進程是否擁有大核心鎖，如果有，它將被釋放，以致於其它的進程能夠獲得該鎖，而當輪到該進程運行時，再讓它重新獲得大核心鎖。注意在保持自旋鎖期間是不運行發生調度的。

需要特別指出，整個核心只有一個大核心鎖，其實不難理解，核心只有一個，而大核心鎖是保護整個核心的，當然有且只有一個就足夠了。

還需要特別指出的是，大核心鎖是曆史遺留，核心中用的非常少，一般保持該鎖的時間較長，因此不提倡使用它。從2.6.11核心起，大核心鎖可以通過配置核心使其變得可搶佔（自旋鎖是不可搶佔的），這時它實質上是一個互斥鎖，使用訊號量實現。

大核心鎖的API包括：

void lock_kernel(void);

該函數用於得到大核心鎖。它可以遞迴調用而不會導致死結。

void unlock_kernel(void);

該函數用於釋放大核心鎖。當然必須與lock_kernel配對使用，調用了多少次lock_kernel，就需要調用多少次unlock_kernel。

大核心鎖的API使用非常簡單，按照以下方式使用就可以了：

lock_kernel();//對被保護的共用資源的訪問…unlock_kernel()；

七、讀寫鎖（rwlock）

讀寫鎖實際是一種特殊的自旋鎖，它把對共用資源的訪問者劃分成讀者和寫者，讀者只對共用資源進行讀訪問，寫者則需要對共用資源進行寫操作。這種鎖相對於自旋鎖而言，能提高並發性，因為在多處理器系統中，它允許同時有多個讀者來訪問共用資源，最大可能的讀者數為實際的邏輯CPU數。寫者是排他性的，一個讀寫鎖同時只能有一個寫者或多個讀者（與CPU數相關），但不能同時既有讀者又有寫者。

在讀寫鎖保持期間也是搶佔失效的。

如果讀寫鎖當前沒有讀者，也沒有寫者，那麼寫者可以立刻獲得讀寫鎖，否則它必須自旋在那裡，直到沒有任何寫者或讀者。如果讀寫鎖沒有寫者，那麼讀者可以立即獲得該讀寫鎖，否則讀者必須自旋在那裡，直到寫者釋放該讀寫鎖。

讀寫鎖的API看上去與自旋鎖很象，只是讀者和寫者需要不同的獲得和釋放鎖的API。下面是讀寫鎖API清單：

rwlock_init(x)

該宏用於動態初始化讀寫鎖x。

DEFINE_RWLOCK(x)

該宏聲明一個讀寫鎖並對其進行初始化。它用於靜態初始化。

RW_LOCK_UNLOCKED

它用於靜態初始化一個讀寫鎖。

DEFINE_RWLOCK(x)等同於rwlock_t x = RW_LOCK_UNLOCKED

read_trylock(lock)

讀者用它來儘力獲得讀寫鎖lock，如果能夠立即獲得讀寫鎖，它就獲得鎖並返回真，否則不能獲得鎖，返回假。無論是否能夠獲得鎖，它都將立即返回，絕不自旋在那裡。

write_trylock(lock)

寫者用它來儘力獲得讀寫鎖lock，如果能夠立即獲得讀寫鎖，它就獲得鎖並返回真，否則不能獲得鎖，返回假。無論是否能夠獲得鎖，它都將立即返回，絕不自旋在那裡。

read_lock(lock)

讀者要訪問被讀寫鎖lock保護的共用資源，需要使用該宏來得到讀寫鎖lock。如果能夠立即獲得，它將立即獲得讀寫鎖並返回，否則，將自旋在那裡，直到獲得該讀寫鎖。

write_lock(lock)

寫者要想訪問被讀寫鎖lock保護的共用資源，需要使用該宏來得到讀寫鎖lock。如果能夠立即獲得，它將立即獲得讀寫鎖並返回，否則，將自旋在那裡，直到獲得該讀寫鎖。

read_lock_irqsave(lock, flags)

讀者也可以使用該宏來獲得讀寫鎖，與read_lock不同的是，該宏還同時把標誌寄存器的值儲存到了變數flags中，並失效了本地中斷。

write_lock_irqsave(lock, flags)

寫者可以用它來獲得讀寫鎖，與write_lock不同的是，該宏還同時把標誌寄存器的值儲存到了變數flags中，並失效了本地中斷。

read_lock_irq(lock)

讀者也可以用它來獲得讀寫鎖，與read_lock不同的是，該宏還同時失效了本地中斷。該宏與read_lock_irqsave的不同之處是，它沒有儲存標誌寄存器。

write_lock_irq(lock)

寫者也可以用它來獲得鎖，與write_lock不同的是，該宏還同時失效了本地中斷。該宏與write_lock_irqsave的不同之處是，它沒有儲存標誌寄存器。

read_lock_bh(lock)

讀者也可以用它來獲得讀寫鎖，與與read_lock不同的是，該宏還同時失效了本地的非強制中斷。

write_lock_bh(lock)

寫者也可以用它來獲得讀寫鎖，與write_lock不同的是，該宏還同時失效了本地的非強制中斷。

read_unlock(lock)

讀者使用該宏來釋放讀寫鎖lock。它必須與read_lock配對使用。

write_unlock(lock)

寫者使用該宏來釋放讀寫鎖lock。它必須與write_lock配對使用。

read_unlock_irqrestore(lock, flags)

讀者也可以使用該宏來釋放讀寫鎖，與read_unlock不同的是，該宏還同時把標誌寄存器的值恢複為變數flags的值。它必須與read_lock_irqsave配對使用。

write_unlock_irqrestore(lock, flags)

寫者也可以使用該宏來釋放讀寫鎖，與write_unlock不同的是，該宏還同時把標誌寄存器的值恢複為變數flags的值，並使能本地中斷。它必須與write_lock_irqsave配對使用。

read_unlock_irq(lock)

讀者也可以使用該宏來釋放讀寫鎖，與read_unlock不同的是，該宏還同時使能本地中斷。它必須與read_lock_irq配對使用。

write_unlock_irq(lock)

寫者也可以使用該宏來釋放讀寫鎖，與write_unlock不同的是，該宏還同時使能本地中斷。它必須與write_lock_irq配對使用。

read_unlock_bh(lock)

讀者也可以使用該宏來釋放讀寫鎖，與read_unlock不同的是，該宏還同時使能本地非強制中斷。它必須與read_lock_bh配對使用。

write_unlock_bh(lock)

寫者也可以使用該宏來釋放讀寫鎖，與write_unlock不同的是，該宏還同時使能本地非強制中斷。它必須與write_lock_bh配對使用。

讀寫鎖的獲得和釋放鎖的方法也有許多版本，具體用哪個與自旋鎖一樣，因此參考自旋鎖部分就可以了。只是需要區分讀者與寫者，讀者要用讀者版本，而寫者必須用寫者版本。

八、大讀者鎖（brlock-Big Reader Lock）

大讀者鎖是讀寫鎖的高效能版，讀者可以非常快地獲得鎖，但寫者獲得鎖的開銷比較大。大讀者鎖只存在於2.4核心中，在2.6中已經沒有這種鎖（提醒讀者特別注意）。它們的使用與讀寫鎖的使用類似，只是所有的大讀者鎖都是事先已經定義好的。這種鎖適合於讀多寫少的情況，它在這種情況下遠好於讀寫鎖。

大讀者鎖的實現機制是：每一個大讀者鎖在所有CPU上都有一個本地讀者寫者鎖，一個讀者僅需要獲得本地CPU的讀者鎖，而寫者必須獲得所有CPU上的鎖。

大讀者鎖的API非常類似於讀寫鎖，只是鎖變數為預定義的鎖ID。

void br_read_lock (enum brlock_indices idx);

讀者使用該函數來獲得大讀者鎖idx，在2.4核心中，預定義的idx允許的值有兩個：BR_GLOBALIRQ_LOCK和BR_NETPROTO_LOCK，當然，使用者可以添加自己定義的大讀者鎖ID 。

void br_read_unlock (enum brlock_indices idx);

讀者使用該函數釋放大讀者鎖idx。

void br_write_lock (enum brlock_indices idx);

寫者使用它來獲得大讀者鎖idx。

void br_write_unlock (enum brlock_indices idx);

寫者使用它來釋放大讀者鎖idx。

br_read_lock_irqsave(idx, flags)

讀者也可以使用該宏來獲得大讀者鎖idx，與br_read_lock不同的是，該宏還同時把寄存器的值儲存到變數flags中，並且失效本地中斷。

br_read_lock_irq(idx)

讀者也可以使用該宏來獲得大讀者鎖idx，與br_read_lock不同的是，該宏還同時失效本地中斷。與br_read_lock_irqsave不同的是，該宏不儲存標誌寄存器。

br_read_lock_bh(idx)

讀者也可以使用該宏來獲得大讀者鎖idx，與br_read_lock不同的是，該宏還同時失效本地非強制中斷。

br_write_lock_irqsave(idx, flags)

寫者也可以使用該宏來獲得大讀者鎖idx，與br_write_lock不同的是，該宏還同時把寄存器的值儲存到變數flags中，並且失效本地中斷。

br_write_lock_irq(idx)

寫者也可以使用該宏來獲得大讀者鎖idx，與br_write_lock不同的是，該宏還同時失效本地中斷。與br_write_lock_irqsave不同的是，該宏不儲存標誌寄存器。

br_write_lock_bh(idx)

寫者也可以使用該宏來獲得大讀者鎖idx，與br_write_lock不同的是，該宏還同時失效本地非強制中斷。

br_read_unlock_irqrestore(idx, flags)

讀者也使用該宏來釋放大讀者鎖idx，它與br_read_unlock不同之處是，該宏還同時把變數flags的值恢複到標誌寄存器。

br_read_unlock_irq(idx)

讀者也使用該宏來釋放大讀者鎖idx，它與br_read_unlock不同之處是，該宏還同時使能本地中斷。

br_read_unlock_bh(idx)

讀者也使用該宏來釋放大讀者鎖idx，它與br_read_unlock不同之處是，該宏還同時使能本地非強制中斷。

br_write_unlock_irqrestore(idx, flags)

寫者也使用該宏來釋放大讀者鎖idx，它與br_write_unlock不同之處是，該宏還同時把變數flags的值恢複到標誌寄存器。

br_write_unlock_irq(idx)

寫者也使用該宏來釋放大讀者鎖idx，它與br_write_unlock不同之處是，該宏還同時使能本地中斷。

br_write_unlock_bh(idx)

寫者也使用該宏來釋放大讀者鎖idx，它與br_write_unlock不同之處是，該宏還同時使能本地非強制中斷。

這些API的使用與讀寫鎖完全一致。

九、RCU(Read-Copy Update)

RCU(Read-Copy Update)，顧名思義就是讀-拷貝修改，它是基於其原理命名的。對於被RCU保護的共用資料結構，讀者不需要獲得任何鎖就可以訪問它，但寫者在訪問它時首先拷貝一個副本，然後對副本進行修改，最後使用一個回調（callback）機制在適當的時機把指向原來資料的指標重新指向新的被修改的資料。這個時機就是所有引用該資料的CPU都退出對共用資料的操作。

RCU也是讀寫鎖的高效能版本，但是它比大讀者鎖具有更好的擴充性和效能。 RCU既允許多個讀者同時訪問被保護的資料，又允許多個讀者和多個寫者同時訪問被保護的資料（注意：是否可以有多個寫者並行訪問取決於寫者之間使用的同步機制），讀者沒有任何同步開銷，而寫者的同步開銷則取決於使用的寫者間同步機制。但RCU不能替代讀寫鎖，因為如果寫比較多時，對讀者的效能提高不能彌補寫者導致的損失。

RCU的API如下；

rcu_read_lock()

讀者在讀取由RCU保護的共用資料時使用該函數標記它進入讀端臨界區。

rcu_read_unlock()

該函數與rcu_read_lock配對使用，用以標記讀者退出讀端臨界區。

synchronize_rcu()

該函數由RCU寫端調用，它將阻塞寫者，直到經過grace period後，即所有的讀者已經完成讀端臨界區，寫者才可以繼續下一步操作。如果有多個RCU寫端調用該函數，他們將在一個grace period之後全部被喚醒。

synchronize_kernel()

其他非RCU的核心代碼使用該函數來等待所有CPU處在可搶佔狀態，目前功能等同於synchronize_rcu，但現在已經不建議使用，而使用synchronize_sched。

synchronize_sched()

該函數用於等待所有CPU都處在可搶佔狀態，它能保證正在啟動並執行中斷處理函數處理完畢，但不能保證正在啟動並執行softirq處理完畢。注意，synchronize_rcu只保證所有CPU都處理完正在啟動並執行讀端臨界區。

void fastcall call_rcu(struct rcu_head *head,                                void (*func)(struct rcu_head *rcu))struct rcu_head {        struct rcu_head *next;        void (*func)(struct rcu_head *head);};

函數call_rcu也由RCU寫端調用，它不會使寫者阻塞，因而可以在中斷上下文或softirq使用。該函數將把函數func掛接到RCU回呼函數鏈上，然後立即返回。一旦所有的CPU都已經完成端臨界區操作，該函數將被調用來釋放刪除的將絕不在被應用的資料。參數head用於記錄回呼函數func，一般該結構會作為被RCU保護的資料結構的一個欄位，以便省去單獨為該結構分配記憶體的操作。需要指出的是，函數synchronize_rcu的實現實際上使用函數call_rcu。

void fastcall call_rcu_bh(struct rcu_head *head,                                void (*func)(struct rcu_head *rcu))

函數call_ruc_bh功能幾乎與call_rcu完全相同，唯一差別就是它把softirq的完成也當作經曆一個quiescent state，因此如果寫端使用了該函數，在進程內容相關的讀端必須使用rcu_read_lock_bh。

#define rcu_dereference(p)     ({ /                                typeof(p) _________p1 = p; /                                smp_read_barrier_depends(); /                                (_________p1); /                                })

該宏用於在RCU讀端臨界區獲得一個RCU保護的指標，該指標可以在以後安全地引用，記憶體柵只在alpha架構上才使用。

除了這些API，RCU還增加了鏈表操作的RCU版本，因為對於RCU，對共用資料的操作必須保證能夠被沒有使用同步機制的讀者看到，所以記憶體柵是非常必要的。

static inline void list_add_rcu(struct list_head *new, struct list_head *head)

該函數把鏈表項new插入到RCU保護的鏈表head的開頭。使用記憶體柵保證了在引用這個新插入的鏈表項之前，新鏈表項的連結指標的修改對所有讀者是可見的。

static inline void list_add_tail_rcu(struct list_head *new,                                        struct list_head *head)

該函數類似於list_add_rcu，它將把新的鏈表項new添加到被RCU保護的鏈表的末尾。

static inline void list_del_rcu(struct list_head *entry)

該函數從RCU保護的鏈表中移走指定的鏈表項entry，並且把entry的prev指標設定為LIST_POISON2，但是並沒有把entry的next指標設定為LIST_POISON1，因為該指標可能仍然在被讀者用於便利該鏈表。

static inline void list_replace_rcu(struct list_head *old, struct list_head *new)

該函數是RCU新添加的函數，並不存在非RCU版本。它使用新的鏈表項new取代舊的鏈表項old，記憶體柵保證在引用新的鏈表項之前，它的連結指標的修正對所有讀者可見。

list_for_each_rcu(pos, head)

該宏用於遍曆由RCU保護的鏈表head，只要在讀端臨界區使用該函數，它就可以安全地和其它_rcu鏈表操作函數（如list_add_rcu）並發運行。

list_for_each_safe_rcu(pos, n, head)

該宏類似於list_for_each_rcu，但不同之處在於它允許安全地刪除當前鏈表項pos。

list_for_each_entry_rcu(pos, head, member)

該宏類似於list_for_each_rcu，不同之處在於它用於遍曆指定類型的資料結構鏈表，當前鏈表項pos為一包含struct list_head結構的特定的資料結構。

list_for_each_continue_rcu(pos, head)

該宏用於在退出點之後繼續遍曆由RCU保護的鏈表head。

static inline void hlist_del_rcu(struct hlist_node *n)

它從由RCU保護的雜湊鏈表中移走鏈表項n，並設定n的ppre指標為LIST_POISON2，但並沒有設定next為LIST_POISON1,因為該指標可能被讀者使用用於遍利鏈表。

static inline void hlist_add_head_rcu(struct hlist_node *n,                                        struct hlist_head *h)

該函數用於把鏈表項n插入到被RCU保護的雜湊鏈表的開頭，但同時允許讀者對該雜湊鏈表的遍曆。記憶體柵確保在引用新鏈表項之前，它的指標修正對所有讀者可見。

hlist_for_each_rcu(pos, head)

該宏用於遍曆由RCU保護的雜湊鏈表head，只要在讀端臨界區使用該函數，它就可以安全地和其它_rcu雜湊鏈表操作函數（如hlist_add_rcu）並發運行。

hlist_for_each_entry_rcu(tpos, pos, head, member)

類似於hlist_for_each_rcu，不同之處在於它用於遍曆指定類型的資料結構雜湊鏈表，當前鏈表項pos為一包含struct list_head結構的特定的資料結構。

對於RCU更詳細的原理、實現機制以及應用請參看作者專門針對RCU發表的一篇文章,"Linux 2.6核心中新的鎖機制--RCU(Read-Copy Update)"。

十、順序鎖（seqlock）

順序鎖也是對讀寫鎖的一種最佳化，對於順序鎖，讀者絕不會被寫者阻塞，也就說，讀者可以在寫者對被順序鎖保護的共用資源進行寫操作時仍然可以繼續讀，而不必等待寫者完成寫操作，寫者也不需要等待所有讀者完成讀操作才去進行寫操作。但是，寫者與寫者之間仍然是互斥的，即如果有寫者在進行寫操作，其他寫者必須自旋在那裡，直到寫者釋放了順序鎖。

這種鎖有一個限制，它必須要求被保護的共用資源不含有指標，因為寫者可能使得指標失效，但讀者如果正要訪問該指標，將導致OOPs。

如果讀者在讀操作期間，寫者已經發生了寫操作，那麼，讀者必須重新讀取資料，以便確保得到的資料是完整的。

這種鎖對於讀寫同時進行的機率比較小的情況，效能是非常好的，而且它允許讀寫同時進行，因而更大地提高了並發性。

順序鎖的API如下：

void write_seqlock(seqlock_t *sl);

寫者在訪問被順序鎖s1保護的共用資源前需要調用該函數來獲得順序鎖s1。它實際功能上等同於spin_lock，只是增加了一個對順序鎖順序號的加1操作，以便讀者能夠檢查出是否在讀期間有寫者訪問過。

void write_sequnlock(seqlock_t *sl);

寫者在訪問完被順序鎖s1保護的共用資源後需要調用該函數來釋放順序鎖s1。它實際功能上等同於spin_unlock，只是增加了一個對順序鎖順序號的加1操作，以便讀者能夠檢查出是否在讀期間有寫者訪問過。

寫者使用順序鎖的模式如下：

write_seqlock(&seqlock_a);//寫作業碼塊…write_sequnlock(&seqlock_a);

因此，對寫者而言，它的使用與spinlock相同。

int write_tryseqlock(seqlock_t *sl);

寫者在訪問被順序鎖s1保護的共用資源前也可以調用該函數來獲得順序鎖s1。它實際功能上等同於spin_trylock，只是如果成功獲得鎖後，該函數增加了一個對順序鎖順序號的加1操作，以便讀者能夠檢查出是否在讀期間有寫者訪問過。

unsigned read_seqbegin(const seqlock_t *sl);

讀者在對被順序鎖s1保護的共用資源進行訪問前需要調用該函數。讀者實際沒有任何得到鎖和釋放鎖的開銷，該函數只是返回順序鎖s1的當前順序號。

int read_seqretry(const seqlock_t *sl, unsigned iv);

讀者在訪問完被順序鎖s1保護的共用資源後需要調用該函數來檢查，在讀訪問期間是否有寫者訪問了該共用資源，如果是，讀者就需要重新進行讀操作，否則，讀者成功完成了讀操作。

因此，讀者使用順序鎖的模式如下：

do {   seqnum = read_seqbegin(&seqlock_a);//讀作業碼塊...} while (read_seqretry(&seqlock_a, seqnum));write_seqlock_irqsave(lock, flags)

寫者也可以用該宏來獲得順序鎖lock，與write_seqlock不同的是，該宏同時還把標誌寄存器的值儲存到變數flags中，並且失效了本地中斷。

write_seqlock_irq(lock)

寫者也可以用該宏來獲得順序鎖lock，與write_seqlock不同的是，該宏同時還失效了本地中斷。與write_seqlock_irqsave不同的是，該宏不儲存標誌寄存器。

write_seqlock_bh(lock)

寫者也可以用該宏來獲得順序鎖lock，與write_seqlock不同的是，該宏同時還失效了本地非強制中斷。

write_sequnlock_irqrestore(lock, flags)

寫者也可以用該宏來釋放順序鎖lock，與write_sequnlock不同的是，該宏同時還把標誌寄存器的值恢複為變數flags的值。它必須與write_seqlock_irqsave配對使用。

write_sequnlock_irq(lock)

寫者也可以用該宏來釋放順序鎖lock，與write_sequnlock不同的是，該宏同時還使能本地中斷。它必須與write_seqlock_irq配對使用。

write_sequnlock_bh(lock)

寫者也可以用該宏來釋放順序鎖lock，與write_sequnlock不同的是，該宏同時還使能本地非強制中斷。它必須與write_seqlock_bh配對使用。

read_seqbegin_irqsave(lock, flags)

讀者在對被順序鎖lock保護的共用資源進行訪問前也可以使用該宏來獲得順序鎖lock的當前順序號，與read_seqbegin不同的是，它同時還把標誌寄存器的值儲存到變數flags中，並且失效了本地中斷。注意，它必須與read_seqretry_irqrestore配對使用。

read_seqretry_irqrestore(lock, iv, flags)

讀者在訪問完被順序鎖lock保護的共用資源進行訪問後也可以使用該宏來檢查，在讀訪問期間是否有寫者訪問了該共用資源，如果是，讀者就需要重新進行讀操作，否則，讀者成功完成了讀操作。它與read_seqretry不同的是，該宏同時還把標誌寄存器的值恢複為變數flags的值。注意，它必須與read_seqbegin_irqsave配對使用。

因此，讀者使用順序鎖的模式也可以為：

do {   seqnum = read_seqbegin_irqsave(&seqlock_a, flags);//讀作業碼塊...} while (read_seqretry_irqrestore(&seqlock_a, seqnum, flags));

讀者和寫者所使用的API的幾個版本應該如何使用與自旋鎖的類似。

如果寫者在操作被順序鎖保護的共用資源時已經保持了互斥鎖保護對共用資料的寫操作，即寫者與寫者之間已經是互斥的，但讀者仍然可以與寫者同時訪問，那麼這種情況僅需要使用順序計數（seqcount），而不必要spinlock。

順序計數的API如下：

unsigned read_seqcount_begin(const seqcount_t *s);

讀者在對被順序計數保護的共用資源進行讀訪問前需要使用該函數來獲得當前的順序號。

int read_seqcount_retry(const seqcount_t *s, unsigned iv);

讀者在訪問完被順序計數s保護的共用資源後需要調用該函數來檢查，在讀訪問期間是否有寫者訪問了該共用資源，如果是，讀者就需要重新進行讀操作，否則，讀者成功完成了讀操作。

因此，讀者使用順序計數的模式如下：

do {   seqnum = read_seqbegin_count(&seqcount_a);//讀作業碼塊...} while (read_seqretry(&seqcount_a, seqnum));void write_seqcount_begin(seqcount_t *s);

寫者在訪問被順序計數保護的共用資源前需要調用該函數來對順序計數的順序號加1，以便讀者能夠檢查出是否在讀期間有寫者訪問過。

void write_seqcount_end(seqcount_t *s);

寫者在訪問完被順序計數保護的共用資源後需要調用該函數來對順序計數的順序號加1，以便讀者能夠檢查出是否在讀期間有寫者訪問過。

寫者使用順序計數的模式為：

write_seqcount_begin(&seqcount_a);//寫作業碼塊…write_seqcount_end(&seqcount_a);

需要特別提醒，順序計數的使用必須非常謹慎，只有確定在訪問共用資料時已經保持了互斥鎖才可以使用。

小結

自linux 2.4以來，核心對SMP的支援越來越好，很大程度上，對SMP的支援，這些鎖機制是非常必要和重要的。基本上，核心開發人員在開發中都會需要使用一些同步機制，本文通過詳細地講解核心中所有的同步機制，使得讀者能夠對核心鎖機制有全面的瞭解和把握。

原文出處(點擊此處)