本文並不打算逐一示範 iOS 中各類鎖的具體用法,一方面市面上此類教程已不勝枚舉,另一方面筆者也不敢自詡有豐厚的實戰積累;同樣,本文也不會過度糾纏於鎖的具體源碼細節,因為那背後牽扯的知識實在太多。真正想做的,是拆解 iOS 開發中常見的幾種鎖究竟是如何實現的、各自的優劣在哪裡、性能差距又從何而來,最後再順帶談談它們的底層基石。
參考 ibireme 那篇著名的《不再安全的 OSSpinLock》,其中一張圖直觀地對比了各類鎖的加解鎖開銷:

下文將按照從上到下(速度由快至慢)的順序逐一剖析。需要特別說明的是:加解鎖速度並不等同於鎖的執行效率,它反映的只是加解鎖這一步操作的複雜程度,下文會用具體例子加以闡釋。閱讀本文前,建議你對 Objective-C 中各類鎖的基本用法已有初步認識。
OSSpinLock 之所以被判定為不再安全,根源在於優先級反轉問題:當低優先級線程持有鎖時,高優先級線程陷入忙等(busy-wait),瘋狂消耗 CPU 時間,反而使得低優先級線程拿不到時間片,無法繼續執行、無法釋放鎖,最終釀成死結。
要理解忙等為何會「餓死」低優先級線程,得先回到操作系統的線程調度機制。現代操作系統管理普通線程時普遍採用時間片輪轉算法(Round Robin,簡稱 RR):每個線程被分配一段時間片(quantum),通常在 10 到 100 毫秒之間。時間片一旦用完,線程便會被掛起、排入等待隊列,直到下一輪被調度。
自旋鎖的使命很單純——確保臨界區同一時刻只有一個線程能進入。它的典型使用模式可以概括為:
do {
Acquire Lock
Critical section // 臨界區
Release Lock
Reminder section // 無需加鎖保護的代碼
}
其中 Acquire Lock 就是用來保護臨界區不被多線程交錯執行的關鍵步驟。
最樸素的實現,無非是定義一個全局變量來標記鎖的狀態:
bool lock = false; // 初始未上鎖,任何線程都可申請
do {
while(lock); // lock 為 true 時不斷自旋,等同申請鎖
lock = true; // 上鎖,其他線程無法獲取
Critical section // 臨界區
lock = false; // 釋放鎖,其他線程得以進入
Reminder section
}
可惜這段代碼存在致命缺陷:若多個線程同時執行到 while 循環,它們都不會被卡住,而是齊刷刷衝進臨界區,鎖也就形同虛設。破解之道很直接——把申請鎖的過程變成一個不可分割的原子操作。
狹義上的原子操作,指的是一條不可被打斷的操作,線程執行期間不會被操作系統掛起,一定會執行到底。在單處理器環境下,一條匯編指令天然就是原子的,因為連中斷也要通過指令來完成。
但在多處理器環境下,能被多個 CPU 同時執行的操作仍然算不上原子。因此真正的原子性必須依賴硬件支持:例如在 x86 平台上,於指令前加上「LOCK」前綴,對應的機器碼執行時會鎖住總線,阻止其他 CPU 執行相同操作,從而在硬件層面保證了原子性。
這些底層概念無需全部吃透,只要知道申請鎖的過程可以用一個原子操作 test_and_set 來完成即可,其偽代碼如下:
bool test_and_set (bool *target) {
bool rv = *target;
*target = TRUE;
return rv;
}
它把 target 置為 1,並返回舊值;真實實現中,這一切都由一條原子指令完成。
至此,自旋鎖的原理便清晰了:
bool lock = false;
do {
while(test_and_set(&lock); // 原子操作
Critical section
lock = false;
Reminder section
}
需要注意的是,如果臨界區執行時間很長,自旋鎖並不是好選擇。前文提到過時間片輪轉:線程可能因時間片耗盡而被強制搶占,也可能主動因 I/O 或睡眠讓出時間片。而 while 循環中的忙等只是白白空轉 CPU,最終還會因超時被系統搶走時間片。倘若臨界區本身就是文件讀寫這類耗時操作,這種忙等簡直是浪費。
在筆者此前探討 GCD 底層實現的文章中,曾簡單介紹過信號量 dispatch_semaphore_t,它最終會調用 sem_wait,而該方法在 glibc 中的實現大致如下:
int sem_wait (sem_t *sem) {
int *futex = (int *) sem;
if (atomic_decrement_if_positive (futex) > 0)
return 0;
int err = lll_futex_wait (futex, 0);
return -1;
}
邏輯是這樣的:先將信號量的值減一並判斷是否大於零,若大於零說明無需等待,直接返回;否則進入 lll_futex_wait(lll 即 low level lock 的縮寫)。該函數以匯編實現,最終調用 SYS_futex 系統調用,使線程進入睡眠、主動讓出時間片。這個函數在互斥鎖的實現中也可能被用到。
主動讓出時間片並不總意味著高效。讓出時間片會觸發操作系統切換到另一個線程,而一次上下文切換通常需要約 10 微秒,且往往至少涉及兩次切換。若等待時間只有區區幾微秒,忙等反而比睡眠更划算。
可以看到,自旋鎖和信號量的實現都相當簡單,這也正是它們加解鎖耗時分列前兩名的原因。再次強調:加解鎖耗時無法準確衡量鎖的效率(比如它體現不出上下文切換的開銷),只能在一定程度上反映實現的複雜度。
pthread 是 POSIX thread 的縮寫,定義了一組跨平台的線程相關 API,pthread_mutex 即互斥鎖。它與信號量的實現思路相似,並不忙等,而是阻塞線程並使其睡眠,需要付出上下文切換的代價。
常見用法如下:
pthread_mutexattr_t attr; pthread_mutexattr_init(&attr); pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL); // 定義鎖的屬性 pthread_mutex_t mutex; pthread_mutex_init(&mutex, &attr); // 創建鎖 pthread_mutex_lock(&mutex); // 申請鎖 // 臨界區 pthread_mutex_unlock(&mutex); // 釋放鎖
相比之前,用法並無太大變化,關鍵在於鎖的類型,例如 PTHREAD_MUTEX_NORMAL、PTHREAD_MUTEX_ERRORCHECK、PTHREAD_MUTEX_RECURSIVE 等,各自特性這裡不再展開,網上資料已很豐富。
一般來說,同一線程只能申請一次鎖,也只有持有鎖時才能釋放,重複申請或釋放未持有的鎖都會導致崩潰。若已持鎖又再次申請,線程會因等待釋放而陷入睡眠,此後再無機會釋放鎖,於是形成死鎖。
這種情形其實並不罕見,比如某函數申請了鎖,卻在臨界區內遞歸調用了自身。所幸 pthread_mutex 支持遞歸鎖,只需把屬性類型改成 PTHREAD_MUTEX_RECURSIVE,就允許同一線程遞歸申請鎖。
申請互斥鎖時調用的 pthread_mutex_lock,在不同系統上實現各異,內部有的借助信號量,有的則直接調用 lll_futex_wait 使線程休眠。
既然臨界區很短時忙等或許更高效,那麼某些版本的實現會先嘗試若干次(例如 1000 次)的 test_and_test,以此在鎖被錯誤使用時提升性能。
此外,由於 pthread_mutex 支持多種類型(如遞歸鎖),加鎖時需要判斷鎖的類型,這也是它實現類似信號量、效率卻略遜一籌的原因。
NSLock 是 Objective-C 以對象形式暴露給開發者的一種鎖,實現非常簡單,通過宏定義了 lock 方法:
#define MLOCK \
- (void) lock {\
int err = pthread_mutex_lock(&_mutex);\
// 錯誤處理 ……\
}
NSLock 內部封裝了一個類型為 PTHREAD_MUTEX_ERRORCHECK 的 pthread_mutex,它以犧牲少量性能為代價換取了錯誤提示能力。
之所以用宏,是因為 OC 內部還有好幾種鎖,它們的 lock 方法幾乎一模一樣,僅內部 pthread_mutex 的類型不同,用宏能簡化重複定義。
NSLock 比 pthread_mutex 略慢,主要在於它多了一層方法調用;不過得益於方法緩存,多次調用帶來的額外開銷並不明顯。
NSCondition 底層依托條件變量(condition variable)pthread_cond_t 實現。條件變量頗像信號量,提供了線程阻塞與信號機制,可用來阻塞某線程、等待某份數據就緒,隨後再喚醒它——典型的生產者-消費者模式便是如此。
介紹 pthread_cond_t 的文章都會強調:它需要與互斥鎖配合使用:
void consumer () { // 消費者
pthread_mutex_lock(&mutex);
while (data == NULL) {
pthread_cond_wait(&condition_variable_signal, &mutex); // 等待數據
}
// ↓↓↓ 有新的數據,以下代碼負責處理
// temp = data;
// ↑↑↑ 有新的數據,以上代碼負責處理
pthread_mutex_unlock(&mutex);
}
void producer () {
pthread_mutex_lock(&mutex);
// 生產數據
pthread_cond_signal(&condition_variable_signal); // 通知消費者有新數據
pthread_mutex_unlock(&mutex);
}
我們自然會問:「若不用互斥鎖,只用條件變量會怎樣?」問題就在於 temp = data; 並非線程安全——在你把 data 讀出來之前,可能已有別的線程改動了它。因此必須保證消費者拿到的數據是線程安全的。
此外,wait 除了會被 signal 喚醒,還可能被「虛假喚醒」,所以需要用 while 循環中的判斷做二次確認。
介紹條件變量的文章雖多,卻大多迴避了一個根本問題:「為什麼要用條件變量?它無非控制了線程執行順序,用信號量或互斥鎖難道模擬不出類似效果?」
筆者談談個人看法:信號量可以在一定程度上替代 condition,但互斥鎖不行。在上述生產者-消費者代碼中,pthread_cond_wait 的本質是一次鎖的轉移——消費者放棄鎖,生產者獲得鎖;同理,pthread_cond_signal 則是鎖從生產者轉移到消費者的過程。
若改用互斥鎖,代碼得改寫成這樣:
void consumer () { // 消費者
pthread_mutex_lock(&mutex);
while (data == NULL) {
pthread_mutex_unlock(&mutex);
pthread_mutex_lock(&another_lock); // 相當於 wait 另一把互斥鎖
pthread_mutex_lock(&mutex);
}
pthread_mutex_unlock(&mutex);
}
問題在於:在等待 another_lock 之前,生產者有可能搶先執行並釋放了 another_lock。也就是說,我們無法保證「釋放鎖」與「等待另一把鎖」這兩個動作是原子的,也就無法保證「先等待、後釋放」的順序。
信號量則沒有這個困擾,因為它的等待與喚醒不講究先後順序,它只表達「有多少資源可用」。不過相較於 pthread_cond_wait 所保證的原子性鎖轉移,單純用信號量似乎仍存在某種風險(暫未查到非原子操作具體有何不妥)。
值得一提的是,使用 condition 還有一個優勢:可以調用 pthread_cond_broadcast 一次通知所有等待中的消費者,這是信號量難以做到的。
NSCondition 其實是把一把互斥鎖和一個條件變量封裝在了一起,把前者的 lock 方法與後者的 wait/signal 統一在 NSCondition 對象中對外暴露:
- (void) signal {
pthread_cond_signal(&_condition);
}
// 該函數實際通過宏定義,展開後即如下
- (void) lock {
int err = pthread_mutex_lock(&_mutex);
}
它的加解鎖過程與 NSLock 幾乎一致,理論上耗時也應相同(實測亦然)。圖中之所以略長,筆者猜測可能是測試者在每次加解鎖前後還附帶了變量的初始化與銷毀操作。
如前所述,遞歸鎖同樣藉由 pthread_mutex_lock 實現,函數內部會判斷鎖的類型,若為遞歸鎖便允許遞歸調用,僅將一個計數器加一,釋放過程同理。
NSRecursiveLock 與 NSLock 的差別,僅在於內部封裝的 pthread_mutex_t 類型不同,前者為 PTHREAD_MUTEX_RECURSIVE。
NSConditionLock 借助 NSCondition 實現,本質就是一個生產者-消費者模型,「條件被滿足」可以理解為生產者提供了新的內容。它內部持有一個 NSCondition 對象以及一個 _condition_value 屬性,初始化時即賦值:
// 簡化版代碼
- (id) initWithCondition: (NSInteger)value {
if (nil != (self = [super init])) {
_condition = [NSCondition new];
_condition_value = value;
}
return self;
}
它的 lockWhenCondition 方法其實就是消費者:
- (void) lockWhenCondition: (NSInteger)value {
[_condition lock];
while (value != _condition_value) {
[_condition wait];
}
}
對應的 unlockWithCondition 方法則扮演生產者,用 broadcast 通知所有消費者:
- (void) unlockWithCondition: (NSInteger)value {
_condition_value = value;
[_condition broadcast];
[_condition unlock];
}
這其實是一個 Objective-C 層面的鎖,本質是以性能換取語法上的簡潔與可讀。
@synchronized 後面需緊跟一個 OC 對象,它實際上把這個對象當作鎖來用。其實現依賴一張哈希表:OC 在底層維護了一個互斥鎖數組(可理解為「鎖池」),通過對傳入對象取哈希值,定位到對應的互斥鎖。
總的來說,從 OSSpinLock 到 @synchronized,每一種鎖都是在性能、安全與易用性之間做權衡。理解它們的底層實現,才能在真實場景中做出恰當的取捨。