GCD详解

GCD(Grand Center Dispatch)是异步执行任务的技术之一。开发者只需要定义想要执行的任务并追加到适当的Dispatch Queue中,GCD就能生成必要的线程并计划执行任务。

GCD的优点:GCD负责生成线程并计划执行任务,其线程管理是作为系统的一部分来实现的,因此可统一管理,所以效率很高,而且形式上十分简洁。

GCD的API:

开发者要做的只是定义想执行的任务并追加到适当的Dispatch Queue( 等待执行的队列)

//^ caret

dispatch_async(queue, ^{

//这个Block是想执行的任务之一

长时间处理

长时间处理结束后,回到主线程

dispatch_async(dispatch_get_main_queue(), ^{

//例如用户界面更新等只可以在主线程可以执行的处理

});

});

两种Dispatch Queue

Serial Dispatch Queue:按照任务(块)加入到queue的顺序,一个一个的执行(先进先出),用于不能改变执行顺序或不想并发执行任务时。但是可以创建多个Serial Dispatch Queu,每一个只有一个任务在执行,则依然有很多个任务在执行。(不能大量生成Serial Dispatch Queu,因为这样会消耗大量内存,引起大量的上下文切换,大幅度降低系统的响应性能。)

Concurrent Dispatch Queue:并行处理多个任务(块),并行执行的数量取决于系统的状态

1、通过API生成Dispatch Queue:dispatch_queue_create

dispatch_queue_t mySerialDispatchQueue =dispatch_queue_create("com.mySerialDispatchQueue.GCD",NULL);

dispatch_queue_t myConcurrentDispatchQueue =dispatch_queue_create("com.myConcurrentDispatchQueue.GCD",DISPATCH_QUEUE_CONCURRENT);

(dispatch_release(mySerialDispatchQueue);)

该函数的第一个参数是queue的名称,可以用NULL,但是署名后对调试很有帮助。

第二个参数为queue的类型,返回值均为dispatch_queue_t类型。

最低sdk版本>=ios6.0来说,GCD对象已经纳入了ARC的管理范围,我们就不需要再手工调用 dispatch_release了,否则的话,在sdk<6.0的时候,即使我们开启了ARC,这个宏OS_OBJECT_USE_OBJC 也是没有的,也就是说这个时候,GCD对象还必须得自己管理,生成的Dispatch Queue必须由程序员负责释放。

2、获取系统提供的Dispatch Queue

Main Dispatch Queue和Global Dispatch Queue

追加到Main Dispatch Queue的处理在主线程的RunLoop中执行:

dispatch_get_main_queue()  //获取Main Dispatch Queue

Global Dispatch Queue是所有应用程序都能够使用的Concurrent Dispatch,它有四个优先级:High、Default、Low、Background Priority。

dispatch_queue_t globalDispatchQueue =dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW,0);//获取

其余API:

dispatch_set_target_queue:修改自己生成的Dispatch Queue的优先级

dispatch_queue_create生成默认优先级

//修改优先级

dispatch_queue_t mySerialDispatchQueue =dispatch_queue_create("com.mySerialDispatchQueue.GCD",NULL);

dispatch_queue_t globalDispatchQueue =dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH,0);

dispatch_set_target_queue(mySerialDispatchQueue, globalDispatchQueue);

注意:如果在多个Serial Dispatch Queue使用该函数指定目标为某一个Serial Dispatch Queue,那么原本应并行执行的多个Serial Dispatch Queue,在目标Serial Dispatch Queue上只能同时执行一个处理。这可用于防止并行执行。

dispatch_after:将任务延迟加载到Dispatch Queue

dispatch_time_ttime =dispatch_time(DISPATCH_TIME_NOW,3ull *NSEC_PER_SEC);

dispatch_after(time,dispatch_get_main_queue(), ^{

NSLog(@"delay");

});

值得注意的是:

上面源代码是在3秒后将block加到Main Dispatch Queue。因为Main Dispatch Queue在主线程的RunLoop中执行,所以比如每隔1/60秒执行的RunLoop中,Block最快在3秒后执行,最慢在3+1/60秒执行。

dispatch_group_async:用于Concurrent Dispatch Queue或者多个Dispatch Queue中的全部处理结束后执行结束处理。

dispatch_group_tgroup =dispatch_group_create();

dispatch_group_async(group, myConcurrentDispatchQueue, ^{

NSLog(@"1");

});

dispatch_group_async(group, myConcurrentDispatchQueue, ^{

NSLog(@"2");

});

dispatch_group_async(group, myConcurrentDispatchQueue, ^{

NSLog(@"3");

});

dispatch_group_async(group, myConcurrentDispatchQueue, ^{

NSLog(@"4");

});

dispatch_group_async(group, myConcurrentDispatchQueue, ^{

NSLog(@"5");

});

dispatch_group_notify(group,dispatch_get_main_queue(), ^{

NSLog(@"finish");

});

finish一定是最后执行的。当1、2、3、4、5执行完毕后,dispatch_group_notify将Block(finish)添加到Main Dispatch Queue中。

指定的Block属于指定的group dispatch_time_t waitTime =dispatch_time(DISPATCH_TIME_NOW,1ull *NSEC_PER_SEC);

longresault =dispatch_group_wait(group, waitTime);

if(resault ==0) {

/*

*属于Dispatch Group的全部处理执行结束

*/

}else{

}

该方法可以检查执行是否全部结束。

dispatch_barrier_async:用于将Dispatch Queue中的并行操作处理完后,再追加。

可实现高效率的数据库访问和文件访问。

dispatch_queue_tbarrierQueue =dispatch_queue_create("com.barrierQueue.GCD",DISPATCH_QUEUE_CONCURRENT);

dispatch_async(barrierQueue, ^{

NSLog(@"r1");

});

dispatch_async(barrierQueue, ^{

NSLog(@"r2");

});

dispatch_barrier_async(barrierQueue, ^{

NSLog(@"w1");

});

dispatch_async(barrierQueue, ^{

NSLog(@"r3");

});

dispatch_async(barrierQueue, ^{

NSLog(@"r4");

});

执行顺序:r1、r2或r2、r1---w1----  r3、r4或r4、r3(w1一定在r1和r2之后执行,在r3和r4之前执行)

dispatch_sync:同步即是将指定的Block追加到Dispatch Queue中并等待Block执行结束才继续执行。

dispatch_queue_tsyncQueue =dispatch_queue_create("my.syncQueue.queue",DISPATCH_QUEUE_CONCURRENT);

dispatch_sync(syncQueue, ^{

NSLog(@"s2");

[NSThreadsleepForTimeInterval:10];

NSLog(@"s3");

});

NSLog(@"s4");

一定最后执行s4

这个方法很容易出现死锁问题:

dispatch_queue_tqueue =dispatch_get_main_queue();

dispatch_sync(queue, ^{NSLog(@"Hello");});

这导致了等待Main Dispatch Queue执行完毕后再执行Main Dispatch Queue的问题。

dispatch_apply:按指定的次数将所有Block追加到Dispatch Queue中,这些Block异步执行,等所有Block全部执行完毕后再往下执行。推荐在dispatch_async中使用。

NSArray*a =@[@"1",@"2",@"3",@"4"];

dispatch_queue_tapplyQueue =dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);

dispatch_apply([acount], applyQueue, ^(size_tindex){

NSLog(@"a:%@",a[index]);

});

NSLog(@"apply Done”);//最后执行

//挂起指定的queueu

dispatch_suspend(globalDispatchQueue);

//恢复指定的queue

dispatch_resume(globalDispatchQueue);

这些函数对已经执行的处理没有影响,刮起后尚未执行的处理在此之后停止执行,而恢复使得这些处理继续进行。

dispatch_semaphore_t:信号量机制,保证访问资源的线程个数

dispatch_queue_tsemaphoreQueue =dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);

NSMutableArray*mutableArray = [NSMutableArrayarray];

for(inti =0; i<100000; i++) {

dispatch_async(semaphoreQueue, ^{

[mutableArrayaddObject:[NSNumbernumberWithInt:i]];

});

}

容易由内存错误导致应用程序异常结束的概率极高

dispatch_queue_tsemaphoreQueue =dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);

//计数初始为1,保证可以访问的线程同时只有一个

dispatch_semaphore_tsemaphore =dispatch_semaphore_create(1);

NSMutableArray*mutableArray = [NSMutableArrayarray];

for(inti =0; i<100000; i++) {

dispatch_async(semaphoreQueue, ^{

//一直等待、直到Dispatch Semaphore的计数大于等于1

dispatch_semaphore_wait(semaphore,DISPATCH_TIME_FOREVER);

//由于初始值为1,上面的函数执行后计数为0,只有一个线程继续往下访问,

//这和操作系统用信号量机制的原理是一样的。

[mutableArrayaddObject:[NSNumbernumberWithInt:i]];

dispatch_semaphore_signal(semaphore);

});

}

dispatch_once:保证在应用程序中只执行一次,生成单例对象时使用

dispatch_once_t pred;

dispatch_once(&pred, ^{

//只执行一次的操作

});

你可能感兴趣的:(GCD详解)