天天看點
傳回

iOS多線程程式設計(三)Grand Central Dispatch(GCD)詳解@dispatch對象

1.基本介紹:

(1) Grand Central Dispatch (GCD)是Apple開發的一個多核程式設計的較新的解決方法。在Mac OS X 10.6雪豹中首次推出，并在最近引入到了iOS4.0。

(2) GCD是一個替代諸如NSThread等技術的很高效和強大的技術。GCD完全可以處理諸如資料鎖定和資源洩漏等複雜的異步程式設計問題。

(3) 它是IOS多線程抽象層次最高的一層，下面還有前面2章節介紹的更加輕量級的Cocoa operations，和Thread。

2.主要方法:

(1)建立一個隊列 　　

　　dispatch_queue_t queue = dispatch_queue_create("LoadImage", NULL);

       其中，第一個參數是辨別隊列的，第二個參數是用來定義隊列的參數（目前不支援，是以傳入NULL）。

(2)執行一個隊列(async--->異步,sync--->同步) 　　

　　dispatch_async(queue, ^{ [self doSomething]; });

        其中，首先傳入之前建立的隊列，然後提供由隊列運作的代碼塊。

(3)聲明并執行一個隊列 (如果不需要保留要運作的隊列的引用)

　　dispatch_async(dispatch_queue_create ("LoadImage", NULL), ^{ [self doSomething]; });

(4)暫停一個隊列 　　

　　dispatch_suspend(queue);

(5)恢複一個隊列(如果暫停一個隊列不要忘記恢複)

       dispatch_resume(queue);

(6)将代碼塊中的工作轉回到主線程(注意，dispatch_suspend （以及dispatch_resume）在主線程上不起作用)

　　dispatch_sync(dispatch_get_main_queue(), ^{ [self dismissLoginWindow]; });

3.代碼示例

#pragma mark - GCD(Grand Central Dispatch)
- (void)GCD{

    dispatch_queue_t queue = dispatch_queue_create("test", NULL);
    
    // 多一個a,異步
    dispatch_async(queue, ^{
        
        for (int i = 0; i < 100; i++) {
            NSLog(@"--多線程--%d",i);
        }
        
        // 判斷是否是在多線程運作環境
        BOOL isMulti = [NSThread isMultiThreaded];
        NSLog(@"%d",isMulti);
        if (isMulti) {
            NSLog(@"*********多線程***********");
        }
        
        // 将代碼塊中的工作轉回到主線程
        dispatch_sync(dispatch_get_main_queue(), ^{
            
            // 判斷是否是在主線程運作環境
            BOOL isMain = [NSThread isMainThread];
            if (isMain) {
                NSLog(@"*********主線程**********");
            }
            
        });
        
    });
    
/*    // 通過此方式,還是運作在目前線程
    dispatch_sync(queue, ^{
        // 主線程
    });
 */   
    for (int i = 0; i < 100; i++) {
        NSLog(@"--主線程--%d",i);
    }
}

4.加載網絡圖檔(在多線程加載明顯比放在主線程加載快N多)

#pragma mark - 給UIImageView寫一個類目
@interface UIImageView (WebCach)

- (void)setImageWithURL:(NSURL *)url;

@end

#import "UIImageView+WebCach.h"

@implementation UIImageView (WebCach)

- (void)setImageWithURL:(NSURL *)url{

    dispatch_queue_t queue = dispatch_queue_create("loadImage", NULL);

    dispatch_async(queue, ^{
        
        NSData * data = [NSData dataWithContentsOfURL:url];
        UIImage * image = [UIImage imageWithData:data];
        
        // 加載UI的操作,一般放在主線程進行
        dispatch_async(dispatch_get_main_queue(), ^{
            
            self.image = image;
        });
        
    });
}

@end

- (void)viewDidLoad
{
    [super viewDidLoad];
	// Do any additional setup after loading the view.

    UIImageView * imageView = [[UIImageView alloc]initWithFrame:CGRectMake(100, 100, 100, 100)];
    [imageView setImageWithURL:[NSURL URLWithString:@"http://www.baidu.com/img/bdlogo.gif"]];
    
    [self.view addSubview:imageView];
    
}

5.最後,引用别人部落格對幾個方法的介紹

@dispatch對象 

原文位址  http://www.cnblogs.com/sunfrog/p/3243230.html

談起iOS的dispatch（正式稱謂是Grand Central Dispatch或GCD），不得不說這又是iOS（包括MacOSX）平台的創新，優缺點這裡不讨論，隻有當你使用時才能真正體會到。我們說dispatch函數的主要目的是實作多任務并發代碼，那麼要了解dispatch函數，先來了解dispatch對象的定義。

 

dispatch對象類型的部分定義，主要使用C語言的宏定義：

<os/object.h>檔案：

#define OS_OBJECT_CLASS(name) OS_##name

#define OS_OBJECT_DECL(name, ...) \

@protocol OS_OBJECT_CLASS(name) __VA_ARGS__ \

@end \

typedef NSObject<OS_OBJECT_CLASS(name)> *name##_t

#define OS_OBJECT_DECL_SUBCLASS(name, super) \

OS_OBJECT_DECL(name, <OS_OBJECT_CLASS(super)>)

 

<dispatch/object.h>檔案：

#define DISPATCH_DECL(name) OS_OBJECT_DECL_SUBCLASS(name, dispatch_object)

#define DISPATCH_GLOBAL_OBJECT(type, object) ((OS_OBJECT_BRIDGE type)&(object))

OS_OBJECT_DECL(dispatch_object); //定義dispatch_object_t

 

<dispatch/queue.h>檔案（dispatch隊列類定義，其它dispatch對象類似）：

DISPATCH_DECL(dispatch_queue); //定義dispatch_queue_t

 

可以通過Xcode預編譯後可以看到最終結果，最終定義的都是NSObject類，雖然它們之間沒用直接繼承關系，但都實作OS_dispatch_object接口，這樣dispatch_queue_t對象也同樣是dispatch_object_t的對象了。下面就是預編譯dispatch_object_t和dispatch_queue_t的結果：

@protocol OS_dispatch_object

@end

typedef NSObject<OS_dispatch_object> *dispatch_object_t;

@protocol OS_dispatch_queue <OS_dispatch_object>

@end

typedef NSObject<OS_dispatch_queue> *dispatch_queue_t;

 

由于dispatch api接口定義成C函數的形式，dispatch的對象都是由C函數形式的廠方法得到（不能繼承dispatch類，不用alloc），這樣做隐藏dispatch對象的具體形态，把注意力放在如何調用dispatch api上。

從上面dispatch對象宏定義可以看到dispatch對象類的名稱一般為dispatch_xyz_t（嚴格來講是對象指針），它們都可以看成dispatch_object_t的子類（對象指針），是以使用dispatch對象時套用這個概念就行。

 

有關dispatch對象的基本接口如下：

void dispatch_retain(dispatch_object_t object); //替代dispatch對象正常的retain來持有對象，但ARC程式設計中不再允許

void dispatch_release(dispatch_object_t object); //替代dispatch對象正常的release來釋放對象，同樣ARC程式設計中不再允許

void dispatch_set_context(dispatch_object_t object, void *context); //給dispatch對象綁定特定資料對象（類似線程的TLS資料），會被傳給dispatch對象的finalizer函數

void *dispatch_get_context(dispatch_object_t object); //傳回dispatch對象綁定的資料對象指針

void dispatch_set_finalizer_f(dispatch_object_t object, dispatch_function_t finalizer); //設定dispatch對象的finalizer函數，當該對象釋放時會調用finalizer，部分代碼解釋如何使用這個函數（ARC模式）：

dispatch_object_t dispatchObject = ...;

void *context = ...;

dispatch_set_context(dispatchObject, context);

dispatch_set_finalizer_f(dispatchObject, finalizer);

......

dispatchObject = nil; //dispatchObject被釋放，這時調用finalizer函數

......

void finalizer(void *context)

{

　　//處理或釋放context相關資源

}

 

dispatch對象的另外兩個接口是：

void dispatch_resume(dispatch_object_t object); //激活（啟動）在dispatch對象上的block調用，可以運作多個block

void dispatch_suspend(dispatch_object_t object); //挂起（暫停）在dispatch對象上的block調用，已經運作的block不會停止

一般這兩個函數的調用必須成對，否則運作會出現異常。

至此你是否發現這兩個函數有些與衆不同呢？好像從來沒有這麼使用對象的，啟動對象--暫停對象，呵呵。這正是了解dispatch對象的關鍵所在。dispatch對象其實是抽象的任務，把動态的任務變成對象來管理。任務是動态的，不存在繼承關系，這就是為什麼GCD沒有提供靜态繼承dispatch對象類的方式。如果能這樣了解，那麼在使用dispatch函數時就能夠更靈活地去編寫代碼，實作各種并發的多任務代碼。

@dispatch隊列

GCD程式設計的核心就是dispatch隊列，dispatch block的執行最終都會放進某個隊列中去進行，它類似NSOperationQueue但更複雜也更強大，并且可以嵌套使用。是以說，結合block實作的GCD，把函數閉包（Closure）的特性發揮得淋漓盡緻。

 

dispatch隊列的生成可以有這幾種方式：

1. dispatch_queue_t queue = dispatch_queue_create("com.dispatch.serial", DISPATCH_QUEUE_SERIAL); //生成一個串行隊列，隊列中的block按照先進先出（FIFO）的順序去執行，實際上為單線程執行。第一個參數是隊列的名稱，在調試程式時會非常有用，所有盡量不要重名了。

2. dispatch_queue_t queue = dispatch_queue_create("com.dispatch.concurrent", DISPATCH_QUEUE_CONCURRENT); //生成一個并發執行隊列，block被分發到多個線程去執行

3. dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); //獲得程式程序預設産生的并發隊列，可設定優先級來選擇高、中、低三個優先級隊列。由于是系統預設生成的，是以無法調用dispatch_resume()和dispatch_suspend()來控制執行繼續或中斷。需要注意的是，三個隊列不代表三個線程，可能會有更多的線程。并發隊列可以根據實際情況來自動産生合理的線程數，也可了解為dispatch隊列實作了一個線程池的管理，對于程式邏輯是透明的。

官網文檔解釋說共有三個并發隊列，但實際還有一個更低優先級的隊列，設定優先級為DISPATCH_QUEUE_PRIORITY_BACKGROUND。Xcode調試時可以觀察到正在使用的各個dispatch隊列。

4. dispatch_queue_t queue = dispatch_get_main_queue(); //獲得主線程的dispatch隊列，實際是一個串行隊列。同樣無法控制主線程dispatch隊列的執行繼續或中斷。

接下來我們可以使用dispatch_async或dispatch_sync函數來加載需要運作的block。

dispatch_async(queue, ^{

　　//block具體代碼

}); //異步執行block，函數立即傳回

dispatch_sync(queue, ^{

　　//block具體代碼

}); //同步執行block，函數不傳回，一直等到block執行完畢。編譯器會根據實際情況優化代碼，是以有時候你會發現block其實還在目前線程上執行，并沒用産生新線程。

實際程式設計經驗告訴我們，盡可能避免使用dispatch_sync，嵌套使用時還容易引起程式死鎖。

如果queue1是一個串行隊列的話，這段代碼立即産生死鎖：

   dispatch_sync(queue1, ^{

      dispatch_sync(queue1, ^{

　　　　......

　　});

　　......

　});

不妨思考下，為什麼下面代碼也肯定死鎖：

dispatch_sync(dispatch_get_main_queue(), ^{

　　......

}); 

 

那實際運用中，一般可以用dispatch這樣來寫，常見的網絡請求資料多線程執行模型：

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

　　//子線程中開始網絡請求資料

　　//更新資料模型

　　dispatch_sync(dispatch_get_main_queue(), ^{

　　　　//在主線程中更新UI代碼

　　});

});

程式的背景運作和UI更新代碼緊湊，代碼邏輯一目了然。

 

dispatch隊列是線程安全的，可以利用串行隊列實作鎖的功能。比如多線程寫同一資料庫，需要保持寫入的順序和每次寫入的完整性，簡單地利用串行隊列即可實作：

dispatch_queue_t queue1 = dispatch_queue_create("com.dispatch.writedb", DISPATCH_QUEUE_SERIAL);

- (void)writeDB:(NSData *)data

{

　　dispatch_async(queue1, ^{

　　　　//write database

　　});

} 

下一次調用writeDB:必須等到上次調用完成後才能進行，保證writeDB:方法是線程安全的。 

 

dispatch隊列還實作其它一些常用函數，包括：

void dispatch_apply(size_t iterations, dispatch_queue_t queue, void (^block)(size_t)); //重複執行block，需要注意的是這個方法是同步傳回，也就是說等到所有block執行完畢才傳回，如需異步傳回則嵌套在dispatch_async中來使用。多個block的運作是否并發或串行執行也依賴queue的是否并發或串行。

void dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block); //這個函數可以設定同步執行的block，它會等到在它加入隊列之前的block執行完畢後，才開始執行。在它之後加入隊列的block，則等到這個block執行完畢後才開始執行。

void dispatch_barrier_sync(dispatch_queue_t queue, dispatch_block_t block); //同上，除了它是同步傳回函數

void dispatch_after(dispatch_time_t when, dispatch_queue_t queue, dispatch_block_t block); //延遲執行block

最後再來看看dispatch隊列的一個很有特色的函數：

void dispatch_set_target_queue(dispatch_object_t object, dispatch_queue_t queue);

它會把需要執行的任務對象指定到不同的隊列中去處理，這個任務對象可以是dispatch隊列，也可以是dispatch源（以後博文會介紹）。而且這個過程可以是動态的，可以實作隊列的動态排程管理等等。比如說有兩個隊列dispatchA和dispatchB，這時把dispatchA指派到dispatchB：

dispatch_set_target_queue(dispatchA, dispatchB);

那麼dispatchA上還未運作的block會在dispatchB上運作。這時如果暫停dispatchA運作：

dispatch_suspend(dispatchA);

則隻會暫停dispatchA上原來的block的執行，dispatchB的block則不受影響。而如果暫停dispatchB的運作，則會暫停dispatchA的運作。

這裡隻簡單舉個例子，說明dispatch隊列運作的靈活性，在實際應用中你會逐漸發掘出它的潛力。

dispatch隊列不支援cancel（取消），沒有實作dispatch_cancel()函數，不像NSOperationQueue，不得不說這是個小小的缺憾。

@dispatch源

原文位址  http://www.cnblogs.com/sunfrog/p/3243230.html

dispatch源（dispatch source）和RunLoop源概念上有些類似的地方，而且使用起來更簡單。要很好地了解dispatch源，其實把它看成一種特别的生産消費模式。dispatch源好比生産的資料，當有新資料時，會自動在dispatch指定的隊列（即消費隊列）上運作相應地block，生産和消費同步是dispatch源會自動管理的。
dispatch源的使用基本為以下步驟：

1. dispatch_source_t source = dispatch_source_create(dispatch_source_type, handler, mask, dispatch_queue); //建立dispatch源，這裡使用加法來合并dispatch源資料，最後一個參數是指定dispatch隊列

2. dispatch_source_set_event_handler(source, ^{ //設定響應dispatch源事件的block，在dispatch源指定的隊列上運作

　　//可以通過dispatch_source_get_data(source)來得到dispatch源資料

});

3. dispatch_resume(source); //dispatch源建立後處于suspend狀态，是以需要啟動dispatch源

4. dispatch_source_merge_data(source, value); //合并dispatch源資料，在dispatch源的block中，dispatch_source_get_data(source)就會得到value。

是不是很簡單？而且完全不必編寫同步的代碼。比如網絡請求資料的模式，就可以這樣來寫：

    dispatch_source_t source = dispatch_source_create(DISPATCH_SOURCE_TYPE_DATA_ADD, 0, 0, dispatch_get_global_queue(0, 0));

    dispatch_source_set_event_handler(source, ^{

        dispatch_sync(dispatch_get_main_queue(), ^{

　　　　//更新UI

        });

    });

    dispatch_resume(source);

    dispatch_async(dispatch_get_global_queue(0, 0), ^{

　　　//網絡請求

        dispatch_source_merge_data(source, 1); //通知隊列

    });

dispatch源還支援其它一些系統源，包括定時器、監控檔案的讀寫、監控檔案系統、監控信号或程序等，基本上調用的方式原理和上面相同，隻是有可能是系統自動觸發事件。比如dispatch定時器：

dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);

dispatch_source_set_timer(timer, dispatch_walltime(NULL, 0), 10*NSEC_PER_SEC, 1*NSEC_PER_SEC); //每10秒觸發timer，誤差1秒

dispatch_source_set_event_handler(timer, ^{

　　//定時處理

});

dispatch_resume(timer);

其它情況的dispatch源就不再一一舉例，可參看官網有具體文檔: https://developer.apple.com/library/ios/documentation/General/Conceptual/ConcurrencyProgrammingGuide/GCDWorkQueues/GCDWorkQueues.html#//apple_ref/doc/uid/TP40008091-CH103-SW1

 

最後，dispatch源的其它一些函數大緻羅列如下：

uintptr_t dispatch_source_get_handle(dispatch_source_t source); //得到dispatch源建立，即調用dispatch_source_create的第二個參數

unsignedlong dispatch_source_get_mask(dispatch_source_t source); //得到dispatch源建立，即調用dispatch_source_create的第三個參數

void dispatch_source_cancel(dispatch_source_t source); //取消dispatch源的事件處理--即不再調用block。如果調用dispatch_suspend隻是暫停dispatch源。

long dispatch_source_testcancel(dispatch_source_t source); //檢測是否dispatch源被取消，如果傳回非0值則表明dispatch源已經被取消

void dispatch_source_set_cancel_handler(dispatch_source_t source, dispatch_block_t cancel_handler); //dispatch源取消時調用的block，一般用于關閉檔案或socket等，釋放相關資源

void dispatch_source_set_registration_handler(dispatch_source_t source, dispatch_block_t registration_handler); //可用于設定dispatch源啟動時調用block，調用完成後即釋放這個block。也可在dispatch源運作當中随時調用這個函數。

@dispatch同步

原文位址  http://www.cnblogs.com/sunfrog/p/3243230.html

GCD提供兩種方式支援dispatch隊列同步，即dispatch組和信号量。
一、dispatch組（dispatch group）

1. 建立dispatch組

dispatch_group_t group = dispatch_group_create(); 

2. 啟動dispatch隊列中的block關聯到group中

dispatch_group_async(group, queue, ^{ 

　　// 。。。 

}); 

3. 等待group關聯的block執行完畢，也可以設定逾時參數

dispatch_group_wait(group, DISPATCH_TIME_FOREVER); 

4. 為group設定通知一個block，當group關聯的block執行完畢後，就調用這個block。類似dispatch_barrier_async。

dispatch_group_notify(group, queue, ^{

　　// 。。。 

}); 

5. 手動管理group關聯的block的運作狀态（或計數），進入和退出group次數必須比對

dispatch_group_enter(group);

dispatch_group_leave(group);

是以下面的兩種調用其實是等價的， 

A)

dispatch_group_async(group, queue, ^{ 

　　// 。。。 

}); 

B) 

dispatch_group_enter(group);

dispatch_async(queue, ^{

　　//。。。

　　dispatch_group_leave(group);

});

是以，可以利用dispatch_group_enter、 dispatch_group_leave和dispatch_group_wait來實作同步，具體例子：http://stackoverflow.com/questions/10643797/wait-until-multiple-operations-executed-including-completion-block-afnetworki/10644282#10644282。

 

二、dispatch信号量（dispatch semaphore）

1. 建立信号量，可以設定信号量的資源數。0表示沒有資源，調用dispatch_semaphore_wait會立即等待。

dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);

2. 等待信号，可以設定逾時參數。該函數傳回0表示得到通知，非0表示逾時。

dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

3. 通知信号，如果等待線程被喚醒則傳回非0，否則傳回0。

dispatch_semaphore_signal(semaphore);

最後，還是回到生成消費者的例子，使用dispatch信号量是如何實作同步：

 

dispatch_semaphore_t sem = dispatch_semaphore_create(0);

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ //消費者隊列

      while (condition) {

　　　　if (dispatch_semaphore_wait(sem, dispatch_time(DISPATCH_TIME_NOW, 10*NSEC_PER_SEC))) //等待10秒

　　　　　　continue;

　　　　//得到資料

　　}

});

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ //生産者隊列

      while (condition) {

 　　　　if (!dispatch_semaphore_signal(sem))

　　　　{

　　　　　　sleep(1); //wait for a while

　　　　　　continue;

　　　　}

　　　　//通知成功

　　}

});
iOS 多線程與網絡 iOS 進階 GCD 程式設計 多線程 多核 線程
上一篇: 面向對象的三大特性 繼承
下一篇: ACM 刷題記錄HDU Multi-University Training Contest

繼續閱讀