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, ^{
//只执行一次的操作
});