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

高效能iOS開發的52個實用技巧(十):深入Grand Central Dispatch

編輯:iOS 開發綜合

本篇速覽

41. 多用派發隊列,少用同步鎖

42. 多用GCD,少用performSelector系列方法

43. 掌握GCD與操作隊列的使用時機

44. 透過Dispatch Group機制,依系統資源狀況執行任務

45. 使用dispatch_once執行僅需運行一次的線程安全代碼

46. 不要使用dispatch_get_current_queue

第41條:多用派發隊列,少用同步鎖

在Objective-C裡,當多個線程需要執行同一份代碼時,往往會引發數據競爭等問題,這時通常得靠鎖來建立同步機制。在GCD問世之前,開發者主要有兩種選擇:

// 使用內建同步塊
- (void)synchronizedMethod{
    @synchronized(self){
        // 安全區間
    }
}
// 使用NSLock對象
_lock = [[NSLock alloc] init];
- (void)synchronizedMethod{
    [_lock lock];
    // 安全區間
    [_lock unlock];
}

這兩種做法本身沒問題,但各有短板。同步塊會拖累執行效率——以本例來說,在self上加鎖意味著當前代碼必須等待另一段毫不相干的代碼執行完畢,才能繼續往下走;而直接使用鎖對象,一旦陷入死鎖便會非常棘手。

更優雅的替代方案是改用GCD。下面以自行實作的原子屬性存取方法為例:

// 用同步塊實作
- (NSString*)someString{
    @synchronized(self){
        return _someString;
    }
}
- (void)setSomeString:(NSString*)someString{
    @synchronized(self){
        _someString = someString;
    }
}
// 用GCD實作
// 建立一個序列隊列
_syncQueue = dispatch_queue_create("com.effectiveobjectivec.syncQueue", NULL);
- (NSString*)someString{
    __block NSString *localSomeString;
    dispatch_sync(_syncQueue, ^{
        localSomeString = _someString;
    });
    return localSomeString;
}
- (void)setSomeString:(NSString*)someString{
    dispatch_sync(_syncQueue, ^{
        _someString = someString;
    });
}

倘若大量屬性都採用@synchronized(self),那麼每個屬性的同步塊都得等其餘所有同步塊跑完才能執行,而且這樣做未必真能保證線程安全。舉例來說,在同一線程上連續呼叫getter,每次取到的值可能都不一樣,因為兩次讀取之間,其他線程也許已經寫入了新值。

本例的GCD版本採用序列同步隊列,把讀取與寫入都排進同一條隊列,藉此確保數據同步。

依實際需求,還能進一步優化。例如「讀取可並發、寫入須獨占」的情境:

// 建立一個並發隊列
_syncQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
- (NSString*)someString{
    __block NSString *localSomeString;
    dispatch_sync(_syncQueue, ^{
        localSomeString = _someString;
    });
    return localSomeString;
}
- (void)setSomeString:(NSString*)someString{
    // 把寫入操作放進異步柵欄塊中執行
    // 說明:barrier即柵欄,並發隊列一旦發現接下來要處理的是柵欄塊,
    // 便會等目前所有並發塊執行完畢,再獨佔執行該柵欄塊,之後才恢復正常並發處理。
    dispatch_barrier_async(_syncQueue, ^{
        _someString = someString;
    });
}

第42條:多用GCD,少用performSelector系列方法

Objective-C本質上是一門極具動態性的語言。NSObject提供了幾個方法,讓開發者能靈活呼叫任意方法,既可延遲執行,也能指定由哪條線程來跑。其中最直白的莫過於performSelector:

- (id)performSelector:(SEL)selector
// performSelector與直接呼叫選擇子等效,以下兩行效果相同
[object performSelector:@selector(selectorName)];
[object selectorName];

當選擇器是在運行期才決定時,performSelector的強大之處便凸顯出來——等於在動態綁定之上再疊加一層動態綁定。

SEL selector;
if(/* 某個條件 */){
    selector = @selector(foo);
}else{
    selector = @selector(bar);
}
[object performSelector:selector];

但這麼寫,在ARC下編譯時編譯器會發出警告,提示performSelector可能導致內存洩漏。根源在於編譯器無從得知即將呼叫的選擇器究竟是什麼,也就無法套用ARC的內存管理規則去判斷返回值該不該釋放。基於謹慎,ARC選擇不加釋放操作,於是當方法返回的對象已被保留時,就會發生洩漏。

performSelector系列方法的另一個局限是:最多只能接兩個參數,且參數類型必須是對象。以下是幾個常用方法:

// 延遲執行
- (id)performSelector:(SEL)selector withObject:(id)argument afterDelay:(NSTimeInterval)delay
// 由指定線程執行
- (id)performSelector:(SEL)selector onThread:(NSThread*)thread withObject:(id)argument waitUntilDone:(BOOL)wait
// 由主線程執行
- (id)performSelectorOnMainThread:(SEL)selector withObject:(id)argument waitUntilDone:(BOOL)wait

這些方法都能用GCD來取而代之:

// 延遲執行
// 使用performSelector
[self performSelector:@selector(doSomething) withObject:nil afterDelay:5.0];
// 使用GCD
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5.0 * NSEC_PER_SEC));
dispatch_after(time, dispatch_get_main_queue(), ^(void){
    [self doSomething];
});
// 在主線程中執行
// 使用performSelector
[self performSelectorOnMainThread:@selector(doSomething) withObject:nil waitUntilDone:NO];
// 使用GCD(若waitUntilDone為YES,則改用dispatch_sync)
dispatch_async(dispatch_get_main_queue(), ^{
    [self doSomething];
});

第43條:掌握GCD與操作隊列的使用時機

GCD的同步機制確實出色,對那些只跑一次的代碼來說尤其方便。但這並不意味著它永遠是最優解——在執行後台任務時,操作隊列(NSOperationQueue)往往是更好的選擇。

兩者差別不小,最關鍵的一點是:GCD是純C的API,而操作隊列是Objective-C對象。在GCD中,任務以塊(block)表示,是極其輕量的數據結構;而操作(NSOperation)則是更重量級的Objective-C對象。究竟選哪種,得在對象帶來的額外開銷與使用完整對象所獲的好處之間權衡。

操作隊列的優勢包括:
1. 直接在NSOperation對象上呼叫cancel即可取消操作,而GCD一旦派發便無法撤銷。
2. 可指定操作間的依賴關係,讓某操作必須等另一操作完成後才能執行。
3. 能透過KVO(鍵值觀察)監控NSOperation的屬性變化(如isCancelled、isFinished)。
4. 可設定操作優先級。
5. 能透過重複使用NSOperation對象來實現更靈活的功能。

想確定哪種方案最佳,最可靠的辦法還是動手做性能測試。

第44條:透過Dispatch Group機制,依系統資源狀況執行任務

dispatch group是GCD的一項特性,能把任務分組。呼叫者既可以等待整組任務跑完,也能在提供回調函數後繼續往下執行,待這組任務完成時再收到通知。

若想讓某容器裡的每個對象都執行一項任務,並等所有任務結束,就可以用這個特性:

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// 建立dispatch group
dispatch_group_t group = dispatch_group_create();
for (id object in collection){
    // 派發任務
    dispatch_group_async(group, queue, ^{
        [object performTask];
    });
}
// 等待組內任務執行完畢
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);

如果當前線程不該被阻塞,又想在所有任務完成後收到通知,可用notify取代wait:

// notify回調所用的隊列可依情況而定,這裡選用主隊列
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
    // 完成任務後接續的處理
});

你也可以把部分任務放到高優先級線程上執行,同時讓所有任務仍屬於同一個group:

// 建立兩個優先級不同的隊列
dispatch_queue_t lowPriorityQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);
dispatch_queue_t highPriorityQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
// 建立dispatch group
dispatch_group_t group = dispatch_group_create();
for (id object in lowPriorityCollection){
    dispatch_group_async(group, lowPriorityQueue, ^{ [object performTask]; });
}
for (id object in highPriorityCollection){
    dispatch_group_async(group, highPriorityQueue, ^{ [object performTask]; });
}
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
    // 完成任務後接續的處理
});

dispatch group並非唯一選擇。若要遍歷某容器並在其每個元素上執行任務,可用apply函數,以下以數組為例:

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_apply(array.count, queue, ^(size_t i) {
    id object = array[i];
    [object performTask];
});

但apply會持續阻塞,直到所有任務都跑完為止。由此可見,一旦把塊派給當前隊列(或體系中層級高於當前隊列的序列隊列),就會導致死鎖。若想在後台執行任務,還是應該改用dispatch group。

第45條:使用dispatch_once執行僅需運行一次的線程安全代碼

單例模式的常見做法是:在類裡寫一個名為sharedInstance的方法,讓它每次都返回同一個共享實例,而非每次呼叫都新建。下面用同步塊來實作單例:

@implementation EOCClass
+ (id)sharedInstance{
    static EOCClass *sharedInstance = nil;
    @synchronized(self){
        if(!sharedInstance){
            sharedInstance = [[self alloc] init];
        }
    }
    return sharedInstance;
}
@end

GCD引入了一項特性,讓單例的實作變得輕鬆許多:

@implementation EOCClass
+ (id)sharedInstance{
    static EOCClass *sharedInstance = nil;
    // 每次呼叫都必須使用完全相同的標志,因此需要將其宣告為static
    static dispatch_once_t onceToken;
    // 只會執行一次
    dispatch_once(&onceToken, ^{
        sharedInstance = [[self alloc] init];
    });
    return sharedInstance;
}
@end

dispatch_once不僅能簡化代碼、徹底保證線程安全,還更高效——所有底層細節都由GCD代為處理,無須動用重量級的同步機制。

第46條:不要使用dispatch_get_current_queue

使用GCD時,我們常需要判斷當前代碼究竟跑在哪條隊列上。dispatch_get_current_queue返回的正是執行當前代碼的隊列。不過iOS與Mac OS X都已將它廢棄,應避免採用。

同步隊列操作有可能引發死鎖:

_syncQueue = dispatch_queue_create("com.effectiveobjectivec.syncQueue", NULL);
- (NSString*)someString{
    __block NSString *localSomeString;
    dispatch_sync(_syncQueue, ^{
        localSomeString = _someString;
    });
    return localSomeString;
}
- (void)setSomeString:(NSString*)someString{
    dispatch_sync(_syncQueue, ^{
        _someString = someString;
    });
}

假如呼叫getter的隊列恰好就是同步操作所針對的隊列(_syncQueue),那麼dispatch_sync便會一直卡住不回,直到塊執行完畢;然而本該執行塊的目標隊列正是當前隊列,它又被阻塞在那裡乾等,於是就形成了死鎖。

這時或許有人會想用dispatch_get_current_queue來化解(其實更好的做法是:確保同步操作所用的隊列永遠不會去存取屬性):

- (NSString*)someString{
    __block NSString *localSomeString;
    dispatch_block_t block = ^{
        localSomeString = _someString;
    };
    // 若執行塊的隊列就是_syncQueue,則不派發,直接執行塊
    if (dispatch_get_current_queue() == _syncQueue) {
        block();
    } else {
        dispatch_sync(_syncQueue, block);
    }
    return localSomeString;
}

但這種做法只能應付簡單情形,遇到下面的場景仍有死鎖風險:

dispatch_queue_t queueA = dispatch_queue_create("com.effectiveobjectivec.queueA", NULL);
dispatch_queue_t queueB = dispatch_queue_create("com.effectiveobjectivec.queueB", NULL);
dispatch_sync(queueA, ^{
    dispatch_sync(queueB, ^{
        dispatch_sync(queueA, ^{
            // 死鎖
        });
    });
});

因為這個操作針對的是queueA,必須等最外層的dispatch_sync執行完畢才行;而最外層又不可能完成,因為它得等最內層的dispatch_sync跑完——於是就死鎖了。

如果試著用dispatch_get_current_queue來解決:

dispatch_sync(queueA, ^{
    dispatch_sync(queueB, ^{
        dispatch_block_t block = ^{ /* ... */ };
        if (dispatch_get_current_queue() == queueA) {
            block();
        } else {
            dispatch_sync(queueA, block);
        }
    });
});

這麼做依然會死鎖,因為dispatch_get_current_queue()返回的是當前隊列,也就是queueB,於是仍然會執行針對queueA的同步派發,結果照樣死鎖。

根本原因在於:派發隊列是按層級組織的,排在某條隊列中的塊會在其上級隊列裡執行。這種層級關係,使得「檢查當前隊列是否為同步派發所用隊列」的思路並不總是奏效。

要妥善解決,最佳途徑是運用GCD提供的「隊列特定數據」功能。它能將任意數據以鍵值對形式關聯到隊列上。最關鍵的是:當取不到關聯數據時,系統會沿層級體系向上查找,直到找到數據或抵達根隊列為止。

dispatch_queue_t queueA = dispatch_queue_create("com.effectiveobjectivec.queueA", NULL);
dispatch_queue_t queueB = dispatch_queue_create("com.effectiveobjectivec.queueB", NULL);
static int kQueueSpecific;
CFStringRef queueSpecificValue = CFSTR("queueA");
// 在queueA上設定隊列特定值
dispatch_queue_set_specific(queueA, &kQueueSpecific, (void*)queueSpecificValue, (dispatch_function_t)CFRelease);
dispatch_sync(queueB, ^{
    dispatch_block_t block = ^{
        NSLog(@"No deadlock!");
    };
    CFStringRef retrievedValue = dispatch_get_specific(&kQueueSpecific);
    if (retrievedValue) {
        block();
    } else {
        dispatch_sync(queueA, block);
    }
});

dispatch_queue_set_specific的首個參數是待設定的隊列,接著兩個參數分別是鍵與值(函數按指針值比較鍵,而非其內容),最後一個參數是析構函數。dispatch_function_t的定義如下:

typedef void (*dispatch_function_t)(void*)

本例傳入CFRelease作為參數,用來清理舊值。

隊列特定數據所帶來的這套簡單易用的機制,正好規避了使用dispatch_get_current_queue時常見的種種陷阱。當然,除錯時仍可使用這個已廢棄的方法,只要別把它編譯進發行版即可。

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