2. 程式人生 > >Linux核心同步方法——讀寫鎖

Linux核心同步方法——讀寫鎖

阿新 • • 發佈：2019-02-07

讀 - 寫自旋鎖

    一個或多個任務可以併發地持有讀者鎖;相反，用於寫的鎖最多隻能被一個寫任務持有，而且此時不能有併發地讀操作。

   讀/寫鎖也叫做共享/排斥鎖，或者併發/排斥鎖，因為這種鎖對讀者而言是共享地，對寫者以排斥形式獲取地。

基本資料結構

    在核心程式碼中，讀-寫自旋鎖用rwlock_t型別表示，

typedef struct {
	/**
	 * 這個鎖標誌與自旋鎖不一樣，自旋鎖的lock標誌只能取0和1兩種值。
	 * 讀寫自旋鎖的lock分兩部分：
	 *     0-23位：表示併發讀的數量。資料以補碼的形式存放。
	 *     24位：未鎖標誌。如果沒有讀或寫時設定該，否則清0
	 * 注意：如果自旋鎖為空（設定了未鎖標誌並且無讀者），則lock欄位為0x01000000
	 *     如果寫者獲得了鎖，則lock為0x00000000（未鎖標誌清0，表示已經鎖，但是無讀者）
	 *     如果一個或者多個程序獲得了讀鎖，那麼lock的值為0x00ffffff,0x00fffffe等（未鎖標誌清0，後面跟讀者數量的補碼）
	 */
	volatile unsigned int lock;
#ifdef CONFIG_DEBUG_SPINLOCK
	unsigned magic;
#endif
#ifdef CONFIG_PREEMPT
	/**
	 * 表示程序正在忙等待自旋鎖。
	 * 只有核心支援SMP和核心搶佔時才使用本標誌。
	 */
	unsigned int break_lock;
#endif
} rwlock_t;

rwlock_t中的鎖標誌與自旋鎖不同，

    （注：如果自旋鎖為空（設定了未鎖標誌並且無讀者），則鎖位元組位0x0100 0000）（自鎖鎖的鎖標誌只能取0和1兩種值。

讀寫自旋鎖的鎖分為兩部分：

    · 0-23位：表示併發讀的數量;

    ·第24位：未鎖標誌如果沒有讀或寫時會設定，否則清0。

如果寫者獲得了鎖，則鎖為0x0000 0000（未鎖標誌清0，表示已經鎖，但無讀者）;如果一個或多個程序獲得了讀鎖，那麼鎖的值為0x00ff ffff，0x00ff fffe鎖標誌清0）。

初始化

    rwlock_init（），初始化指定的rwlock_t。

#define rwlock_init(x)	do { *(x) = RW_LOCK_UNLOCKED; } while(0)

read_lock

    獲得指定的讀鎖。

    在沒有配置核心搶佔時，read_lock的實現如下，

/**
 * 在沒有配置核心搶佔時，read_lock的實現。
 */
void __lockfunc _read_lock(rwlock_t *lock)
{
	preempt_disable();
	_raw_read_lock(lock);
}
EXPORT_SYMBOL(_read_lock);

    接下來，read_lock呼叫_raw_read_lock（），其中第一個引數為讀寫鎖指標，第二個為獲取讀鎖失敗時的處理函式的函式指標。

/**
 * 在沒有配置核心搶佔時，read_lock呼叫它。
 */
static inline void _raw_read_lock(rwlock_t *rw)
{
#ifdef CONFIG_DEBUG_SPINLOCK
	BUG_ON(rw->magic != RWLOCK_MAGIC);
#endif
	__build_read_lock(rw, "__read_lock_failed");
}

__build_read_lock

    函式raw_read_lock呼叫巨集函式__build_read_lock，

這裡的__builtin_constant_p（）是編譯器的GCC的內建函式，用於判斷一個值是否為編譯時常量，如果是，函式返回1，否則返回0。

#define __build_read_lock(rw, helper)	do { \
						if (__builtin_constant_p(rw)) \
							__build_read_lock_const(rw, helper); \
						else \
							__build_read_lock_ptr(rw, helper); \
					} while (0)

__build_read_lock_ptr和__build_read_lock_const

    在沒有核心搶佔時，助手為__read_lock_failed。

/**
 * 在沒有核心搶佔時，read_lock會調到這裡來。
 * 在那種情況下，helper為__read_lock_failed
 */
#define __build_read_lock_ptr(rw, helper)   \
	/**
	 * 將lock減1，變相是將讀者數加1
	 */
	asm volatile(LOCK "subl $1,(%0)\n\t" \
			 /**
			  * 如果減1後，lock值>=0。就說明此時未鎖，或者只有讀者，申請讀鎖成功。
			  */
		     "jns 1f\n" \
		     /**
		      * 此時有寫者，申請不成功，轉到__read_lock_failed
		      */
		     "call " helper "\n\t" \
		     "1:\n" \
		     ::"a" (rw) : "memory")

#define __build_read_lock_const(rw, helper)   \
	asm volatile(LOCK "subl $1,%0\n\t" \
		     "jns 1f\n" \
		     "pushl %%eax\n\t" \
		     "leal %0,%%eax\n\t" \
		     "call " helper "\n\t" \
		     "popl %%eax\n\t" \
		     "1:\n" \
		     :"=m" (*(volatile int *)rw) : : "memory")


read_unlock（）

    釋放指定的讀鎖。

void __lockfunc _read_unlock(rwlock_t *lock)
{
	_raw_read_unlock(lock);
	preempt_enable();
}
EXPORT_SYMBOL(_read_unlock);
#define _raw_read_unlock(lock)	do { (void)(lock); } while(0)

write_lock（）

    獲得指定的寫鎖。

void __lockfunc _write_lock(rwlock_t *lock)
{
	preempt_disable();
	_raw_write_lock(lock);
}
static inline void _raw_write_lock(rwlock_t *rw)
{
#ifdef CONFIG_DEBUG_SPINLOCK
	BUG_ON(rw->magic != RWLOCK_MAGIC);
#endif
	__build_write_lock(rw, "__write_lock_failed");
}

__build_write_lock（）原始碼

    和__build_read_lock（）程式碼類似，

#define __build_write_lock(rw, helper)	do { \
						if (__builtin_constant_p(rw)) \
							__build_write_lock_const(rw, helper); \
						else \
							__build_write_lock_ptr(rw, helper); \
					} while (0)

__build_write_lock_ptr（）和__build_write_lock_const

#define __build_write_lock_ptr(rw, helper) \
	//鎖匯流排，將rw減RW_LOCK_BIAS_STR，即rw減0x01000000，判斷結果是否為0，若為0則獲取寫鎖成功並返回
	asm volatile(LOCK "subl $" RW_LOCK_BIAS_STR ",(%0)\n\t" \
		     "jz 1f\n" \
		      //若結果不為0則獲取寫鎖失敗，呼叫失敗處理函式helper
		     "call " helper "\n\t" \
		     "1:\n" \
		     ::"a" (rw) : "memory")

#define __build_write_lock_const(rw, helper) \
	asm volatile(LOCK "subl $" RW_LOCK_BIAS_STR ",%0\n\t" \
		     "jz 1f\n" \
		     "pushl %%eax\n\t" \
		     "leal %0,%%eax\n\t" \
		     "call " helper "\n\t" \
		     "popl %%eax\n\t" \
		     "1:\n" \
		     :"=m" (*(volatile int *)rw) : : "memory")

write_unlock（）

    釋放指定的寫鎖。

    在獲得鎖時是禁止搶佔的，此時要把搶佔開啟。順序與鎖定相反。


void __lockfunc _write_unlock(rwlock_t *lock)
{
	/**
	 * 調用匯編lock ; addl $0x01000000, rwlp把欄位中的未鎖標誌置位。
	 */
	_raw_write_unlock(lock);
	/**
	 * 當然了，在獲得鎖時是禁用搶佔的，此時要把搶佔開啟。
	 * 另外，注意它的順序，是與lock時相反。
	 */
	preempt_enable();
}
EXPORT_SYMBOL(_write_unlock);

調用匯編lock;加$ 0x01000000，把rw欄位中的未鎖標誌置位。

#define _raw_write_unlock(rw)	asm volatile("lock ; addl $" RW_LOCK_BIAS_STR ",%0":"=m" ((rw)->lock) : : "memory")

read_unlock（）

    釋放指定的讀鎖。
__build_write_lock_ptr（）和__build_write_lock_const

核心中的讀 - 寫自旋鎖具體應用的型別

獲取讀寫鎖的操作

    read_lock_irqsave（）儲存本地中斷的當前狀態，禁止本地中斷並獲得指定讀鎖。

unsigned long __lockfunc _read_lock_irqsave(rwlock_t *lock)
{
	unsigned long flags;

	local_irq_save(flags);
	preempt_disable();
	_raw_read_lock(lock);
	return flags;
}
EXPORT_SYMBOL(_read_lock_irqsave);

   read_lock_irq（）禁止本地中斷並獲得指定讀鎖。

void __lockfunc _read_lock_irq(rwlock_t *lock)
{
	local_irq_disable();
	preempt_disable();
	_raw_read_lock(lock);
}
EXPORT_SYMBOL(_read_lock_irq);

      __write_lock_irqsave（）儲存本地中斷的當前狀態，禁止本地中斷並獲得指定寫鎖。

unsigned long __lockfunc _write_lock_irqsave(rwlock_t *lock)
{
	unsigned long flags;

	local_irq_save(flags);
	preempt_disable();
	_raw_write_lock(lock);
	return flags;
}
EXPORT_SYMBOL(_write_lock_irqsave);

    _write_lock_irq（）禁止本地中斷並獲得指定寫鎖。

void __lockfunc _write_lock_irq(rwlock_t *lock)
{
	local_irq_disable();
	preempt_disable();
	_raw_write_lock(lock);
}
EXPORT_SYMBOL(_write_lock_irq);

釋放讀寫鎖的操作

    _read_unlock_irqrestore（）釋放指定的讀鎖並將本地中斷恢復到指定的前狀態（標誌）。
void __lockfunc _spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags)
{
	_raw_spin_unlock(lock);
	local_irq_restore(flags);
	preempt_enable();
}
    _read_unlock_irq（）釋放指定的讀鎖並激活本地中斷。
void __lockfunc _read_unlock_irq(rwlock_t *lock)
{
	_raw_read_unlock(lock);
	local_irq_enable();
	preempt_enable();
}

read_unlock（）

    釋放指定的讀鎖。
__build_write_lock_ptr（）和__build_write_lock_const
    _write_unlock_irqrestore（）和_read_unlock_irqrestore（）函式功能類似，釋放指定的寫鎖並將本地中斷恢復到指定的前狀態。
void __lockfunc _read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
{
	_raw_read_unlock(lock);
	local_irq_restore(flags);
	preempt_enable();
}
    _write_unlock_irq（）釋放指定的寫鎖，並激活本地中斷。
void __lockfunc _write_unlock_irq(rwlock_t *lock)
{
	_raw_write_unlock(lock);
	local_irq_enable();
	preempt_enable();
}

write_trylock（）

    試圖獲得指定的寫鎖;如果寫鎖不可用，返回非0值。

int __lockfunc _write_trylock(rwlock_t *lock)
{
	preempt_disable();
	if (_raw_write_trylock(lock))
		return 1;

	preempt_enable();
	return 0;
}
#define _raw_write_trylock(lock) ({ (void)(lock); (1); })

總結：

（1）或一個多個讀任務可以併發地持有同一個倫敦報道讀者鎖 ;相反，用於寫的鎖最多隻能被一個寫任務持有。

（2）一個執行緒遞迴地獲得同一讀鎖也是安全的。

（3）如果在中斷處理程式中只有讀操作而沒有寫操作，那麼就可以混合使用“中斷禁止”鎖，即使用read_lock（）而不是read_lock_irqsave（）對鎖進行保護。

（4）讀寫鎖對於讀更好一些。當讀鎖被持有時，寫操作是為了互斥訪問只能等待，但讀者卻可以繼續成功地佔用鎖。而自旋鎖等待地寫者在所有讀者釋放鎖之前是無法獲得鎖的。所以大量的讀者必定會使掛起寫者處於飢餓狀態，消耗處理器資源。

（5）如果加鎖時間不長御姐程式碼不會睡眠（比如中斷處理程式），利用自旋鎖是最佳選擇;

        如果加鎖時間可能很長或程式碼在持有鎖時有可能睡眠，那麼適合使用訊號量。

補充：

禁止搶佔

    。核心中的搶佔程式碼使用自旋鎖作為非搶佔區域的標記如果一個自旋鎖被持有，核心便不能進行搶佔。但是，自旋鎖對於單處理器（或者是資料對每個處理器是唯一的）的情況，是不需要鎖保護的。

    由於核心是搶佔性地，核心中的程序在任何時刻都肯停下來以便另一個具有更高優先順序的程序執行。這意味著一個任務與被強佔的任務可能會在同一個臨界區內執行。

preempt_disable（）

    增加搶佔計數值，從而禁止核心搶佔。這是一個巢狀呼叫函式。每次呼叫都需要有一個對應的preempt_enable（）呼叫。

preemp_enable（）

    減少搶佔計數，並當該值降為0時檢查和執行掛起的需排程的任務。也就是說，當是什麼意思？求最後一次preempt_enable（）被呼叫後，核心搶佔才重新啟用。

preempt_count（）

    返回搶佔計數。

    搶佔計數是被持有鎖的數量和preempt_disable（）的呼叫次數。如果計數是0，那麼核心可以搶佔;如果為1或更大的數，核心就不會搶佔。這個計數是一種對原子操作和睡眠有效的除錯方法。



read_unlock（）

    釋放指定的讀鎖。__build_write_lock_ptr（）和__build_write_lock_const

總結：

（1）或一個多個讀任務可以併發地持有同一個倫敦報道讀者鎖 ;相反，用於寫的鎖最多隻能被一個寫任務持有。

（2）一個執行緒遞迴地獲得同一讀鎖也是安全的。

（3）如果在中斷處理程式中只有讀操作而沒有寫操作，那麼就可以混合使用“中斷禁止”鎖，即使用read_lock（）而不是read_lock_irqsave（）對鎖進行保護。

（4）讀寫鎖對於讀更好一些。當讀鎖被持有時，寫操作是為了互斥訪問只能等待，但讀者卻可以繼續成功地佔用鎖。而自旋鎖等待地寫者在所有讀者釋放鎖之前是無法獲得鎖的。所以大量的讀者必定會使掛起寫者處於飢餓狀態，消耗處理器資源。

（5）如果加鎖時間不長御姐程式碼不會睡眠（比如中斷處理程式），利用自旋鎖是最佳選擇;

        如果加鎖時間可能很長或程式碼在持有鎖時有可能睡眠，那麼適合使用訊號量。

補充：

禁止搶佔

    。核心中的搶佔程式碼使用自旋鎖作為非搶佔區域的標記如果一個自旋鎖被持有，核心便不能進行搶佔。但是，自旋鎖對於單處理器（或者是資料對每個處理器是唯一的）的情況，是不需要鎖保護的。

    由於核心是搶佔性地，核心中的程序在任何時刻都肯停下來以便另一個具有更高優先順序的程序執行。這意味著一個任務與被強佔的任務可能會在同一個臨界區內執行。

preempt_disable（）

    增加搶佔計數值，從而禁止核心搶佔。這是一個巢狀呼叫函式。每次呼叫都需要有一個對應的preempt_enable（）呼叫。

preemp_enable（）

    減少搶佔計數，並當該值降為0時檢查和執行掛起的需排程的任務。也就是說，當是什麼意思？求最後一次preempt_enable（）被呼叫後，核心搶佔才重新啟用。

preempt_count（）

    返回搶佔計數。

    搶佔計數是被持有鎖的數量和preempt_disable（）的呼叫次數。如果計數是0，那麼核心可以搶佔;如果為1或更大的數，核心就不會搶佔。這個計數是一種對原子操作和睡眠有效的除錯方法。

相關推薦

Linux核心同步方法——讀寫鎖

讀 - 寫自旋鎖    一個或多個任務可以併發地持有讀者鎖;相反，用於寫的鎖最多隻能被一個寫任務持有，而且此時不能有併發地讀操作。   讀/寫鎖也叫做共享/排斥鎖，或者併發/排斥鎖，因為這種鎖對讀者而言是共享地，對寫者以排斥形式獲取地。基本資料結構    在核心程式碼中，讀-

Linux 學習筆記—執行緒同步之讀寫鎖、自旋鎖、屏障

3.2.1 讀寫鎖 讀寫鎖和互斥體類似，不過讀寫鎖有更高的並行性，互斥體要麼是鎖住狀態，要麼是不加鎖狀態，而且一次只有一個執行緒可以對其加鎖。而讀寫鎖可以有3個狀態，讀模式下鎖住狀態，寫模式下鎖住狀態，不加鎖狀態。一次只有一個執行緒可以佔有寫模式的讀寫鎖，但是多

線程同步之讀寫鎖（鎖操作的補充）

允許 資源 加鎖 函數 申請 tex bject def 讀取 輕量級的讀寫鎖（Slim Reader-Writer locks）：讀寫鎖實際是一種特殊的自旋鎖，它把對共享資源的訪問者劃分成讀者和寫者，讀者只對共享資源進行讀訪問，寫者則需要對共享資源進行寫操作。這種鎖相對於

17.執行緒同步：讀寫鎖rwlock

1.讀寫鎖 讀鎖：共享 寫鎖：獨佔 1.多個執行緒可以對同一個共享資源加[讀鎖] 2.但是隻要有一個[寫鎖]到來，後面申請的鎖全部會阻塞 3.寫鎖優先：防止[寫操作]一直等待下去 當已經加了讀鎖，此時再來了寫鎖請求，之後又來了讀鎖請求====>後面到來的讀鎖請求不能 請求成功，只

Linux下pthread的讀寫鎖的優先順序問題

有這麼一個情況：有一個C實現的HashMap，需要在多個執行緒之間共享。對它的讀操作遠遠大於寫操作。所以採用了pthread的讀寫鎖來保障併發讀寫時的一致性。 現在測試發現的問題是：因為讀操作太多，導致寫操作一直拿不到鎖。按理說不應該啊，假如有三個執行緒，執行緒1 先申

linux執行緒間同步(通訊)的幾種方法——互斥鎖、條件變數、訊號量、讀寫鎖

Linux下提供了多種方式來處理執行緒同步，最常用的是互斥鎖、條件變數、訊號量和讀寫鎖。  下面是思維導圖：  一、互斥鎖（mutex）  　　鎖機制是同一時刻只允許一個執行緒執行一個關鍵部分的程式碼。 1 . 初始化鎖 int pthread_mutex_init(p

linux c 執行緒間同步（通訊）的幾種方法--互斥鎖，條件變數，訊號量，讀寫鎖

轉載自：https://blog.csdn.net/vertor11/article/details/55657619Linux下提供了多種方式來處理執行緒同步，最常用的是互斥鎖、條件變數、訊號量和讀寫鎖。 下面是思維導圖： 一、互斥鎖（mutex） 　　鎖機制是同一時刻只允

Linux：使用讀寫鎖使線程同步

解釋 -s write des 返回值 沒有 enter red bubuko 基礎與控制原語 讀寫鎖 與互斥量類似，但讀寫鎖允許更高的並行性。其特性為：寫獨占，讀共享。 讀寫鎖狀態： 一把讀寫鎖具備三種狀態： 1. 讀模式下加鎖狀態 (讀鎖)

Linux多執行緒程式設計---執行緒間同步（互斥鎖、條件變數、訊號量和讀寫鎖）

本篇博文轉自http://zhangxiaoya.github.io/2015/05/15/multi-thread-of-c-program-language-on-linux/ Linux下提供了多種方式來處理執行緒同步，最常用的是互斥鎖、條件變數、訊號量和讀寫鎖。  下面是思維導

Linux環境程式設計之同步(三)：讀寫鎖

概述 相互排斥鎖把試圖進入我們稱之為臨界區的全部其它執行緒都堵塞住。該臨界區通常涉及對由這些執行緒共享一個或多個數據的訪問或更新。讀寫鎖在獲取讀寫鎖用於讀某個資料和獲取讀寫鎖用於寫直接作差別。 讀寫鎖的分配規則例如以下： 1、僅僅要沒有執行緒持有某個給定的讀寫鎖用於寫。那麼

Linux程式設計學習筆記----多執行緒程式設計執行緒同步機制之互斥量(鎖)與讀寫鎖

互斥鎖通訊機制 基本原理 互斥鎖以排他方式防止共享資料被併發訪問,互斥鎖是一個二元變數,狀態為開(0)和關(1),將某個共享資源與某個互斥鎖邏輯上繫結之後,對該資源的訪問操作如下: (1)在訪問該資源之前需要首先申請互斥鎖,如果鎖處於開狀態,則申請得到鎖並立即上鎖(關),防

筆記：程序間通訊——同步(互斥鎖、讀寫鎖、條件變數、訊號量）以及Linux中的RCU

1.互斥鎖 多個執行緒的IPC，需要同步，同步有隱式的和顯示的： 比如unix提供的管道和FIFO，由核心負責同步，比如read發生在write之前，那麼read就會被核心阻塞，這中同步是由核心負責的，使用者不會感知。 但如果使用共享區作為生產者和消費者之間的IPC，那麼程

linux下多執行緒同步機制之訊號量、互斥量、讀寫鎖、條件變數

之前有寫過類似的部落格，這東西不用老忘，現在又有更清晰的理解了。 一、訊號量 編譯時候加入-lrt 訊號量最基本的兩個操作就是PV操作：P()操作實現訊號量減少，V()操作實現訊號量的增加 訊號量的值取決於訊號量的型別，訊號量的型別有多種： （1）二進位制訊號量：0與1.

WINDOWS 同步（Interlocked，InterlockedExchangeAdd，Slim讀/寫鎖，WaitForSingleObject，CreateWaitableTimer等等）

延遲 align .net 屬於 替代 技巧 led 存在 resume NOTE0 在以下兩種基本情況下，線程之間需要相互通信： 需要讓多個線程同時訪問一個共享資源，同時不能破壞資源的完整性； 一個線程需要通知其它線程某項任務已經完成 1.原子訪問：Int

Linux—Centos7.4之搭建Mysql數據庫主從同步、讀寫分離

搭建Mysql主從同步、讀寫分離MySQL主從同步與讀寫分離 目錄第一部分 實驗環境第二部分 配置主從同步第三部分 配置讀寫分離第四部分 測試驗證 第一部分 實驗環境 實驗拓撲圖： 服務器五臺：1）客戶端服務器一臺：IP地址：192.168.80.10（client）需安裝軟件：mysql-bo

C#使用讀寫鎖解決多線程並發寫入文件時線程同步的問題

fin 問題 final [] 解決 同步 write main sta 讀寫鎖是以 ReaderWriterLockSlim 對象作為鎖管理資源的，不同的 ReaderWriterLockSlim 對象中鎖定同一個文件也會被視為不同的鎖進行管理，這種差異可能會再次導致文件

linux下用互斥鎖和條件變數來實現讀寫鎖

以下內容來源自UNP卷二的第八章 讀寫鎖的概念( the conception of read-write lock ) (1)只要沒有執行緒持有某個給定的讀寫鎖用於寫，那麼任意數目的執行緒可以持有該執行緒用於讀 (2)僅當沒有執行緒持有某個給定的讀寫鎖用於讀或用於寫，才能分配該

讀/寫鎖同步資料存取

讀/寫鎖同步資料存取 準備工作 工作原理 更多關注 ReadWriteLock介面和實現此介面的ReentrantReadWriteLock特殊類是鎖機制提供的最顯著改進之一。此類包含兩種鎖：一種是讀取操作鎖，一種是寫入操作鎖。多個執行緒能夠同

29-執行緒同步——讀寫鎖

1. 讀寫鎖   讀寫鎖跟互斥量是類似的，也是一種鎖，但讀寫鎖相當於互斥鎖的加強版。   因為互斥鎖缺乏併發性，例如有多個執行緒要對資料進行讀取操作，互斥鎖每次只能支援一個執行緒訪問，而讀寫鎖則支援多個執行緒同時進行讀取操作。   還是拿銀行取錢的例子來說，假

基本執行緒同步（六）使用讀/寫鎖同步資料訪問

宣告：本文是《 Java 7 Concurrency Cookbook 》的第二章，作者： Javier Fernández González     譯者：許巧輝 使用讀/寫鎖同步資料訪問 鎖所提供的最重要的改進之一就是ReadWriteLock介面和唯一 一個實現它的ReentrantRe