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

深入剖析 dispatch_queue:動手打造一個簡易版 GCD

編輯:iOS 開發基礎

本文由 CocoaChina 譯者 candeladiao(GitHub)翻譯

作者:Mike Ash(Blog、GitHub)

原文:Friday Q&A 2015-09-04: Let's Build dispatch_queue


Grand Central Dispatch 是 Apple 過去幾年打造出的非常強大的 API。在 Let's Build 系列的最新一期中,我們將探究 dispatch_queue 基礎功能的重新實現。這個主題是 Rob Rix 提議的。

概述

dispatch queue 是一個工作隊列,背後是一個全局的執行緒池。特別是,提交到隊列的任務會在後台執行緒中異步執行。所有執行緒共享同一個後台執行緒池,這讓系統更有效率。

這也是我將要模仿的 API 的精髓部分。GCD 還提供了許多精心設計的功能,為簡單起見,本文將它們全部略過。比如,執行緒池的執行緒數量會依待完成的任務數與系統 CPU 使用率動態調整——如果你已經有一堆任務佔滿了 CPU,再丟給它另一個任務,GCD 不會再建立額外的工作執行緒,因為 CPU 已經被 100% 佔用,再執行別的任務只會更低效。這裡我會把執行緒數寫死而不做動態調整的模擬,同時也會忽略併發隊列的目標隊列與調度屏障功能。

我們的目標是聚焦 dispatch queue 的真髓:能串行、能併行、能同步、能異步,以及共享同一個執行緒池。

編碼

和以往一樣,今天文章的程式碼可以在 GitHub 找到:https://github.com/mikeash/MADispatchQueue

如果你想邊讀邊自己探索,以上是所有程式碼。

介面

GCD 是基於 C 語言的 API。雖然最新系統版本中 GCD 物件已轉成 Objective-C 物件,但 API 仍保持純 C 介面(加了 block 擴充)。這對實作底層介面是好事——GCD 提供了出色而簡單的介面,但就個人而言,我更喜歡用 Objective-C 來實作。

Objective-C 類別名為 MADispatchQueue,包含四個呼叫方法:

1. 取得全局共享隊列的方法。GCD 有多個不同優先級的全局隊列,出於簡單考慮,我們在實作中保留一個。

2. 串行與併行隊列的初始化函數。

3. 異步分發呼叫。

4. 同步分發呼叫。

介面聲明:

   @interface MADispatchQueue : NSObject         + (MADispatchQueue *)globalQueue;      - (id)initSerial: (BOOL)serial;      - (void)dispatchAsync: (dispatch_block_t)block;      - (void)dispatchSync: (dispatch_block_t)block;      @end

接下來的目標,就是實現這些方法的功能。

執行緒池介面

隊列背後的執行緒池介面更簡單,它才真正執行提交的任務,而隊列負責在合適的時機把已入隊的任務交給它。

執行緒池只做一件事:投遞任務並運行。對應地,一個介面只有一個方法:

@interface MAThreadPool : NSObject     - (void)addBlock: (dispatch_block_t)block; @end

由於這是核心部分,我們先實現它。

執行緒池實作

先看實例變量。執行緒池能被多個內部或外部執行緒訪問,因此需要執行緒安全。而在可能的情況下,GCD 會使用原子操作,我這裡則採用一種以前比較流行的方式——加鎖。我需要知道鎖處於等待狀態與鎖相關的信號,而不僅僅強制互斥,因此我使用 NSCondition 而非 NSLock。如果你不熟悉,NSCondition 本質上仍是鎖,只是額外提供了一個條件變量:

NSCondition *_lock;

想知道何時增加工作執行緒,我需要知道執行緒池裡的執行緒數、有多少執行緒正被佔用,以及所能擁有的最大執行緒數:

    NSUInteger _threadCount;     NSUInteger _activeThreadCount;     NSUInteger _threadCountLimit;

最後,得有一個 NSMutableArray 類型的 block 列表來模擬隊列,從隊列後端添加新 block,從隊列前端刪除:

NSMutableArray *_blocks;

初始化函數很簡單:初始化鎖與 block 陣列,隨便設一個最大執行緒數,比如 128:

    - (id)init {         if((self = [super init])) {                     _lock = [[NSCondition alloc] init];                     _blocks = [[NSMutableArray alloc] init];                     _threadCountLimit = 128;         }         return self;     }

工作執行緒運行一個簡單的無限循環。只要 block 陣列為空,它就一直等待;一旦有 block 加入,它就把它從陣列中取出並執行,同時把活動執行緒數加 1,完成後再減 1:

- (void)workerThreadLoop: (id)ignore {

首先要取得鎖。注意需要在循環開始前獲得,至於原因,等寫到循環結束時你就會明白。

    [_lock lock];

無限循環開始:

    while(1) {

如果隊列為空,等待鎖:

            while([_blocks count] == 0) {                 [_lock wait];             }

注意:這裡是內循環結束而非 if 判斷。原因是由於虛假喚醒——簡單說,wait 在沒有信號通知的情況下也有可能返回,為此,條件檢測的正確方式是:當 wait 返回時重新進行條件檢測。

一旦隊列中有 block,取出:

            dispatch_block_t block = [_blocks firstObject];             [_blocks removeObjectAtIndex: 0];

活動執行緒計數加 1,表示有新執行緒正在處理任務:

            _activeThreadCount++;

現在執行 block,我們得先釋放鎖,否則程式碼併發執行時會出現死鎖:

            [_lock unlock];

安全釋放鎖後,執行 block:

            block();

block 執行完畢,活動執行緒計數減 1。該操作必須在鎖內做,以避免競態條件,最後是循環結束:

            [_lock lock];             _activeThreadCount--;         }     }

現在你該明白為什麼需要在進入循環前獲得鎖了。循環的最後是在鎖內減少活動執行緒計數,循環開始時檢測 block 隊列。透過在循環外第一次獲得鎖,後續循環迭代就能用同一把鎖來完成,而不是「鎖、解鎖、再立即上鎖」。

下面是 addBlock:

- (void)addBlock: (dispatch_block_t)block {

這裡唯一需要做的是取得鎖:

    [_lock lock];

把一個新 block 加到 block 隊列:

    [_blocks addObject: block];

如果有一個空閒的工作執行緒去執行這個 block,這裡什麼都不用做;如果沒有足夠的工作執行緒去處理等待的 block,而工作執行緒數也沒超限,則我們需要建立一個新執行緒:

    NSUInteger idleThreads = _threadCount - _activeThreadCount;     if([_blocks count] > idleThreads && _threadCount < _threadCountLimit) {                 [NSThread detachNewThreadSelector: @selector(workerThreadLoop:)                                         toTarget: self                                        withObject: nil];                 _threadCount++;     }


一切就緒。由於空閒執行緒都在休眠,喚醒它:

    [_lock signal];

最後釋放鎖:

    [_lock unlock];     }

執行緒池能在達到預設的最大執行緒數前建立工作執行緒,以處理對應的 block。現在,以此為基礎來實現隊列。

隊列實作

和執行緒池一樣,隊列使用鎖保護其內容;不同的是,它不需要等待鎖,也不需要信號觸發,僅僅是簡單互斥即可,因此採用 NSLock:

    NSLock *_lock;

和執行緒池一樣,它把 pending block 存在 NSMutableArray 裡。

NSMutableArray *_pendingBlocks;

標識是串行還是併行隊列:

BOOL _serial;

如果是串行隊列,還需要標識當前是否有執行緒正在運行:

BOOL _serialRunning;

併行隊列裡有無線程都一樣處理,所以無需關注。

全局隊列是一個全局變量,共享執行緒池也一樣,它們都在 +initialize 裡建立:

    static MADispatchQueue *gGlobalQueue;     static MAThreadPool *gThreadPool;     + (void)initialize {         if(self == [MADispatchQueue class]) {                     gGlobalQueue = [[MADispatchQueue alloc] initSerial: NO];                     gThreadPool = [[MAThreadPool alloc] init];         }     }

由於 +initialize 裡已經初始化了,+globalQueue 只需回傳該變量。

    + (MADispatchQueue *)globalQueue {         return gGlobalQueue;     }

這裡所做的事情和 dispatch_once 是一樣的,但在實作 GCD API 時使用 GCD API 有點自欺欺人,即使程式碼不一樣。

初始化一個隊列:初始化 lock 與 pending Blocks,設定 _serial 變量:

    - (id)initSerial: (BOOL)serial {         if ((self = [super init])) {                     _lock = [[NSLock alloc] init];                     _pendingBlocks = [[NSMutableArray alloc] init];                     _serial = serial;         }         return self;     }

實作剩下的公有 API 前,我們需先實作一個底層方法,用於給執行緒分發一個 block,然後繼續呼叫自己去處理另一個 block:

    - (void)dispatchOneBlock {

整個生命週期所做的,就是在執行緒池上運行 block,分發程式碼如下:

    [gThreadPool addBlock: ^{

然後取隊列中的第一個 block,顯然這需要在鎖內完成,以避免出問題:

            [_lock lock];             dispatch_block_t block = [_pendingBlocks firstObject];             [_pendingBlocks removeObjectAtIndex: 0];             [_lock unlock];

取到了 block 又釋放了鎖,接下來 block 就能安全地在後台執行緒執行了:

            block();

如果是併行執行就不需要再做啥了;如果是串行執行,還需要以下操作:

            if(_serial) {

串行隊列裡會積累別的 block,但在先前的 block 完成前不能執行。block 完成後,dispatchOneBlock 接下來會看是否還有其他 block 被加進隊列。若有,它呼叫自己去處理下一個 block;若無,則把隊列的運行狀態設為 NO:

                [_lock lock];                 if([_pendingBlocks count] > 0) {                     [self dispatchOneBlock];                 } else {                     _serialRunning = NO;                 }                 [_lock unlock];             }         }];     }

用以上方法來實作 dispatchAsync: 就非常容易了。把 block 加到 pending block 隊列,合適的時候設定狀態並呼叫 dispatchOneBlock:

    - (void)dispatchAsync: (dispatch_block_t)block {         [_lock lock];         [_pendingBlocks addObject: block];

如果串行隊列空閒,把隊列狀態設為運行並呼叫 dispatchOneBlock 進行處理。

        if(_serial && !_serialRunning) {             _serialRunning = YES;             [self dispatchOneBlock];

如果隊列是併行的,直接呼叫 dispatchOneBlock。由於多個 block 能併行執行,這樣能保證即使有別的 block 正在運行,新的 block 也能立即執行。

        } else if (!_serial) {             [self dispatchOneBlock];         }

如果串行隊列已經在運行,則不需要另外做處理——因為 block 執行完成後對 dispatchOneBlock 的呼叫,最終會執行到加入隊列的 block。接著釋放鎖:

        [_lock unlock];     }

對於 dispatchSync:,GCD 的處理更巧妙,它是直接在呼叫執行緒上執行 block,以防止其他 block 在隊列上執行(如果是串行隊列)。這裡我們不做如此聰明的處理,只是對 dispatchAsync: 進行封裝,讓它一直等待直到 block 執行完成。

它使用局部 NSCondition 來處理,另外用一個 done 變量來指示 block 何時完成:

    - (void)dispatchSync: (dispatch_block_t)block {         NSCondition *condition = [[NSCondition alloc] init];         __block BOOL done = NO;

下面是異步分發 block。block 裡面呼叫傳入的 block,然後設定 done 的值,給 condition 發信號:

        [self dispatchAsync: ^{             block();             [condition lock];             done = YES;             [condition signal];             [condition unlock];         }];

在呼叫執行緒裡面,等待信號 done,然後返回:

        [condition lock];         while (!done) {             [condition wait];         }         [condition unlock];     }

到此,block 的執行就結束了,這也是 MADispatchQueue API 的最後一點內容。

結論

全局執行緒池可以用 block 隊列與智能產生的執行緒來實現。使用一個共享全局執行緒池,就能建構一個能提供基本串行/併行、同步/異步功能的 dispatch queue。這樣就重建了一個簡單的 GCD——雖然缺少了許多優秀特性且效率更低,但它讓我們得以一窺其內部運作過程,揭示它畢竟不是那麼神秘(除了 dispatch_once 依然神秘)。

今天就到這裡。下次再帶給大家有趣的東西。Friday Q&A 的內容取決於讀者的想法,因此如果你有什麼想在下次或以後了解的,請聯繫我。
(譯者註:作者此前已將網站上 Friday Q&A 系列文章整理成一本書,開發者可在 iBooks 和 Kindle 上查看,另外還有 PDF 與 ePub 格式供下載。)

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