您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發基礎

iOS 多執行緒到底不安全在哪裡?atomic 與 nonatomic 的真相

編輯:iOS 開發基礎

iOS 多執行緒安全的概念在很多場合都會遇到,但「為什麼不安全」、「不安全又該如何定義」,其實是個值得深究的話題。

共享狀態最典型的場景,就是多個執行緒同時存取同一個物件的 property。我們就從 property 的多執行緒安全談起。

Property

說到 property 的多執行緒安全,很多人第一反應是加上 atomic 修飾詞就能一定程度的保障安全:

@property (atomic, strong) NSString*                 userName;

事情並沒有看起來這麼簡單。要分析 property 在多執行緒下的表現,先得把 property 的類型區分清楚。

可以粗略分成值類型與物件類型:值類型指 int、long、bool 等 primitive type;物件類型宣告為指標,指向某塊符合型別定義的記憶體區域。

上述的 userName 顯然是物件類型。而當我們存取 userName 時,存取的可能是「指標本身」,也可能是「指標所指向的記憶體區域」。

例如:

self.userName = @"peak";

是在對指標本身賦值。而

[self.userName rangeOfString:@"peak"];

是在存取指標所指向的字串所在的記憶體區域。兩者完全不同。

因此可以把 property 大致分成三類:

記憶體佈局

談多執行緒安全,本質上談的是多個執行緒同時存取同一塊記憶體區域的問題。針對同一塊區域只有兩種操作:讀(load)與寫(store)。當讀與寫同時發生在同一塊區域上,就有可能出現不安全。所以先來看上述三類 property 的記憶體模型:

以 64 位元系統為例,指標 NSString* 是 8 個位元組的區域,int count 是 4 個位元組,而 @"Peak" 是一塊長度隨字串內容變化的區域。

所以存取 property 時,實際上是在存取上圖這三塊區域:

self.userName = @"peak";

修改的是第一塊。

self.count = 10;

修改的是第二塊。

[self.userName rangeOfString:@"peak"];

讀取的是第三塊。

「不安全」的定義

Wikipedia 的說法是:

A piece of code is thread-safe if it manipulates shared data structures only in a manner that guarantees safe execution by multiple threads at the same time

這段定義有點抽象。我們可以把多執行緒不安全直白地解釋為:多執行緒存取時出現了意料之外的結果。這個「意料之外」包含多種場景,不一定都是 crash。

先看多執行緒如何同時存取記憶體。不考慮 CPU cache 的影響,記憶體存取可以簡化為下圖:

從圖中不難看出:只有一條位址匯流排、一份記憶體。即使多執行緒環境下,也不可能存在兩個執行緒真正「同時」存取同一塊記憶體的情況——存取一定是排隊串行的。由此可以確定兩個結論:

結論一:記憶體存取是串行的,不會因此導致資料錯亂或 App crash。

結論二:若讀寫的記憶體長度小於等於位址匯流排長度,該讀寫是原子操作,一次完成。例如 bool、int、long 在 64 位元系統下的單次讀寫都是原子的。

值類型 Property

先看 BOOL:

@property (nonatomic, assgin) BOOL    isDeleted; //thread 1 bool isDeleted = self.isDeleted; //thread 2 self.isDeleted = false;

執行緒 1 讀、執行緒 2 寫,兩者對 isDeleted 的存取會有先後之分,但一定排隊串行。而 BOOL 只有 1 個位元組,64 位元系統的讀寫指令可支援 8 個位元組長度,因此對 BOOL 的讀寫可以視為原子操作。也就是說,從原子性角度看,宣告 BOOL 型別的 property 時用 atomic 或 nonatomic 並無實際差別(除非你重載了 getter)。

那麼 int 呢?

@property (nonatomic, assgin) int    count; //thread 1 int curCount = self.count; //thread 2 self.count = 1;

int 長度 4 位元組,讀寫都能用一個指令完成,理論上同樣是原子的,nonatomic 與 atomic 也沒什麼差別。

那 atomic 到底有什麼用?據我所知有兩個:

用處一:生成原子操作的 getter 與 setter。加上 atomic 之後,預設產生的 getter/setter 執行是原子的——當執行緒 1 在跑 getter 時(建立呼叫堆疊、返回位址、出堆疊),執行緒 2 想跑 setter 就必須先等它完成。舉例來說,在 32 位元系統上若用 getter 回傳 64 位的 double,由於匯流排只有 32 位,讀取 double 無法一次完成;若沒有透過 atomic 加鎖,很可能在讀取途中被另一個執行緒的 setter 插入,從而得到異常值——這就是多執行緒不安全。

用處二:設置 Memory Barrier。對 Objective-C 的實作而言,幾乎所有加鎖操作最後都會設置 memory barrier,atomic 本質上是給 getter/setter 加了鎖,因此也會設置。官方文件的說法是:

Note: Most types of locks also incorporate a memory barrier to ensure that any preceding load and store instructions are completed before entering the critical section.

memory barrier 的作用是保證記憶體操作的順序,按我們撰寫程式碼的順序執行。聽起來不可思議,但編譯器確實會做優化,在它認為合理的場景下改變程式碼最終翻譯出的機器指令順序。也就是說:

self.intA = 0;  //line 1 self.intB = 1;  //line 2

編譯器在某些場景下可能先執行 line2 再執行 line1,因為它認為 A 與 B 之間不存在依賴關係——即使實際 runtime 中,另一個執行緒要求 line1 必須先於 line2。設為 atomic 之後,就能保證 line1 一定先於 line2。這種場景極為罕見,需要同时满足「變數跨執行緒存在依賴」與「編譯器恰好做了此類優化」兩個條件。我寫 iOS 至今還沒遇過,較可能的原因是編譯器已經在該有的地方替我設置了 memory barrier。

那用了 atomic 就一定安全嗎?看這段程式碼:

@property (atomic, assign)    int       intA; //thread A for (int i = 0; i < 10000; i ++) {     self.intA = self.intA + 1;     NSLog(@"Thread A: %d\n", self.intA); } //thread B for (int i = 0; i < 10000; i ++) {     self.intA = self.intA + 1;     NSLog(@"Thread B: %d\n", self.intA); }

即使把 intA 宣告為 atomic,最終結果也不一定會是 20000。原因是 self.intA = self.intA + 1; 並不是原子操作:雖然 getter 與 setter 各自是原子的,但整句話至少包含讀取(load)、加一(add)、賦值(store)三步。當前的執行緒在 store 時,其他執行緒可能已經 store 過若干次,導致最終值小於預期。這同樣屬於多執行緒不安全。

指標 Property

指標 property 通常指向一個物件:

@property (atomic, strong) NSString*                 userName;

無論 32 位元還是 64 位元系統,指標的值都能用一個指令完成 load 或 store。但與 primitive type 不同的是,物件類型還牽涉記憶體管理。MRC 時代,系統預設產生的 setter 大致如下:

- (void)setUserName:(NSString *)userName {     if(_uesrName != userName) {         [userName retain];         [_userName release];         _userName = userName;     } }

除了賦值,還有 retain 與 release。若 property 為 nonatomic,這個 setter 就不是原子操作。可以設想:執行緒 1 先透過 getter 拿到當前 _userName,接著執行緒 2 呼叫 setter 執行了 [_userName release];,此時執行緒 1 手上的 _userName 就變成了無效的位址空間,再對它發送訊息就會 crash。

到了 ARC 時代,retain 與 release 已由編譯器代勞,絕大部分時候我們不必操心記憶體管理。但它們其實仍存在於最終執行的程式碼中,因此 atomic 與 nonatomic 對物件類 property 而言理論上仍有差異。不過實務上我把 NSString* 設為 nonatomic 也從未遇到上述場景,很可能 ARC 在記憶體管理上的優化已經處理掉了。就我個人經驗:若只是對物件類 property 做讀寫,atomic 與 nonatomic 在多執行緒安全上並無實質差別。

指標 Property 所指向的記憶體區域

這一類才是真正容易踩坑的地方——即使宣告為 atomic 也照樣出錯,因為我們存取的不是指標區域本身,而是它所指向的記憶體。

@property (atomic, strong) NSString*                 stringA; //thread A for (int i = 0; i < 100000; i ++) {     if (i % 2 == 0) {         self.stringA = @"a very long string";     }     else {         self.stringA = @"string";     }     NSLog(@"Thread A: %@\n", self.stringA); } //thread B for (int i = 0; i < 100000; i ++) {     if (self.stringA.length >= 10) {         NSString* subStr = [self.stringA substringWithRange:NSMakeRange(0, 10)];     }     NSLog(@"Thread B: %@\n", self.stringA); }

stringA 是 atomic,取 substring 前也做了 length 判斷,但執行緒 B 依然很容易 crash:前一刻讀 length 時 stringA 是「a very long string」,下一刻取 substring 時執行緒 A 已經把它改成了「string」,於是立刻拋出 out of bounds 例外。

同樣的問題也出現在集合類操作上:

@property (atomic, strong) NSArray*                 arr; //thread A for (int i = 0; i < 100000; i ++) {     if (i % 2 == 0) {         self.arr = @[@"1", @"2", @"3"];     }     else {         self.arr = @[@"1"];     }     NSLog(@"Thread A: %@\n", self.arr); } //thread B for (int i = 0; i < 100000; i ++) {     if (self.arr.count >= 2) {         NSString* str = [self.arr objectAtIndex:1];     }     NSLog(@"Thread B: %@\n", self.arr); }

即使存取 objectAtIndex 之前判斷了 count,執行緒 B 依舊容易 crash——原因是前後兩行之間,arr 所指向的記憶體區域已被其他執行緒換掉了。

所以真正需要警惕的正是這一類區域的存取:宣告 atomic 也救不了你。我們平時遇到的那些莫名其妙、難以重現的多執行緒 crash,大多屬於這一類。

小結:atomic 的作用只是給 getter 與 setter 加了把鎖,它只能保證程式碼「進入 getter/setter 內部時」是安全的;一旦出了 getter/setter,多執行緒安全就只能靠開發者自己。所以 atomic 屬性與使用 property 時的多執行緒安全並沒有直接關聯。另外 atomic 的加鎖本身也有效能損耗,因此實務上我們通常宣告為 nonatomic,在真正需要執行緒安全的場景自行加鎖同步。

如何做到多執行緒安全?

關鍵字是 atomicity(原子性)。只要做到原子性,無論是一個 primitive type 變數的存取,還是一大段程式邏輯的執行,都能保證程式碼串行執行、執行到一半不會被另一個執行緒插入。

原子性是相對概念,粒度可大可小。例如:

if (self.stringA.length >= 10) {     NSString* subStr = [self.stringA substringWithRange:NSMakeRange(0, 10)]; }

這是非原子性的。但加鎖之後:

//thread A [_lock lock]; for (int i = 0; i < 100000; i ++) {     if (i % 2 == 0) {         self.stringA = @"a very long string";     }     else {         self.stringA = @"string";     }     NSLog(@"Thread A: %@\n", self.stringA); } [_lock unlock]; //thread B [_lock lock]; if (self.stringA.length >= 10) {     NSString* subStr = [self.stringA substringWithRange:NSMakeRange(0, 10)]; } [_lock unlock];

整段程式碼就具備了原子性,也就達成了多執行緒安全。集合類的例子同理:

//thread A [_lock lock]; for (int i = 0; i < 100000; i ++) {     if (i % 2 == 0) {         self.arr = @[@"1", @"2", @"3"];     }     else {         self.arr = @[@"1"];     }     NSLog(@"Thread A: %@\n", self.arr); } [_lock unlock];      //thread B [_lock lock]; if (self.arr.count >= 2) {     NSString* str = [self.arr objectAtIndex:1]; } [_lock unlock];

注意:讀和寫都要加鎖。這也正是為什麼我們實踐多執行緒安全時,不是靠給 property 加 atomic,而是宣告為 nonatomic(省掉 getter/setter 的鎖開銷)後自行加鎖。

該選哪一種鎖?

iOS 常用的加鎖方式有:

  • @synchronized(token)

  • NSLock

  • dispatch_semaphore_t

  • OSSpinLock

這幾種都能帶來原子性,效能損耗由上至下依次遞減。

我的建議是:撰寫應用層程式碼時,除了 OSSpinLock 之外,哪個順手用哪個。相較於這幾種鎖的效能差異,程式邏輯的正確性重要得多,而且它們之間的差異絕大部分時候使用者根本感知不到。

當然少數場景確實需要追求效能,例如撰寫 framework,或多執行緒高頻讀寫共享資料時,這時才需要大致了解鎖的損耗量级。官方文件提供過一個數據:在 2 GHz Core Duo、1 GB RAM 的 Intel iMac 上跑 OS X v10.5,取得一次 mutex 約有 0.2ms 損耗——也就是說,鎖的損耗大致在毫秒級。

Atomic Operations

除了各種鎖,iOS 還提供了另一種取得原子性的途徑:Atomic Operations。它的損耗比鎖小約一個數量級,在一些追求高效能的第三方 framework 中可見其身影。這些 API 可以在 /usr/include/libkern/OSAtomic.h 中查到:

例如:

_intA ++;

是非原子性的。而

OSAtomicIncrement32(&(_intA));

是原子性的、多執行緒安全的。

需要注意的是,Atomic Operation 只能套用於 32 位元或 64 位元的資料型別。多執行緒下操作 NSString、NSArray 這類物件,仍然得靠鎖。

大部分 Atomic Operation 都有 OSAtomicXXX 與 OSAtomicXXXBarrier 兩個版本。Barrier 就是前面提到的 memory barrier,在多執行緒、多變數存在依賴時使用 Barrier 版本,能保證正確的執行順序。

日常撰寫應用層的多執行緒安全程式碼,我仍建議多用 @synchronized、NSLock 或 dispatch_semaphore_t——多執行緒安全比多執行緒效能更重要,應該在前者得到充分保證、仍有餘力時再去追求後者。

盡量避免多執行緒的設計

無論寫過多少程式碼,我們都必須承認:多執行緒安全是一個複雜的問題。作為開發者,我們應該盡可能避免多執行緒設計,而不是去追求「高明地使用鎖」的技巧。

後續我會再寫一篇文章介紹函數式編程及其核心思想——即使使用 Objective-C 這類非函數式語言,它也能極大幫助我們規避多執行緒安全問題。

總結

iOS 下多執行緒不安全的分析到此結束。如何寫出多執行緒安全的程式碼,說到底還是在於對 memory layout 與原子性的理解,也希望這篇文章把 atomic 與 nonatomic 的真正差別說清楚了。

歡迎關注公眾號:MrPeakTech

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved