iOS GCD
2015-12-02 23:50
429 查看
一、GCD是异步执行任务的技术之一，一般将应用程序中记叙的线程管理用的代码在系统级中是实现。
开发者只需要定义想要执行的任务并追加到适当的Dispatch Queue中，GCD就能生成必要的线程并计划执行任务。
二、多线程编程
由于使用多线程的程序可以在某个线程和其他线程之间反复多次进行上下文切换，因此看上去就好像一个CPU核能够并行的执行多个线程一样，而且在具有多个CPU核的情况下，就不是“看上去像”了，而是真的提供了多个CPU核并行执行任务的多个线程的技术。
多线程编程容易发生各种编程问题：比如多个线程更新相同的资源会导致数据的不一致（数据竞争）、停止等待事件的线程会导致多个线程相互持续等待（死锁）、使用太多线程会消耗大量的内存资源等等。
尽管会有问题，但是为什么还要用呢？
在应用程序启动时，通过最先执行的线程，即主线程来描绘用户界面、处理用户触摸事件等，但是如果在该主线程中进行长时间的处理，就会妨碍主线程中被称为RunLoop的主循环的执行，从而导致不能跟新用户界面，应用程序的画面长时间停滞等问题。
三、GCD 的 API
1.Dispatch Queue
开发者要做的只是定义想要执行的任务并追加到适当的DispatchQueue中。
在Block中定义想要执行的任务，然后追加到Dispatch Queue中
Dispatch Queue是执行处理的等待队列，通过dispatch_async等API，在Block语法中记叙想要执行的处理并将其追加到Dispatch Queue中，Dispatch Queue按照追加的顺序（FIFO）执行处理。
另外，在执行处理时存在两种Dispatch Queue：
Dispatch Queue的种类
说明
Serial Dispatch Queue
等待现在执行中处理结束
Concurrent Dispatch Queue
不等待现在执行中处理结束
解释说明一下：
（1） Serial Dispatch Queue：就是要等待现在执行中处理结束后才可以进行下一个任务的执行处理，假如现在有blk1，blk2，blk3，在Serial Dispatch Queue中，那么同时执行处理数只能是一个，而且按按添加顺序FIFO进行处理，即先执行blk1，执行结束后再执行blk2，执行结束再进行blk3的执行。
（2） Concurrent Dispatch Queue：就是一个线程的执行不等待现在（当前）执行中的任务处理结束就可以开始另一个任务的执行处理。同样假如有blk1，blk2，blk3在Concurrent Dispatch Queue中，那么首先执行blk1，不管blk1是否执行处理结束，都开始执行后面的blk2，不管blk2是否执行结束，都开始执行后面的blk2。
这样虽然不用等待处理结束，可以并行执行多个任务处理，但是并行处理数取决于当前系统的状态，有它决定Concurrent Dispatch Queue中并行执行的处理数。所谓并行执行就是使用多个线程来同时执行多个处理任务（block中的执行任务）。
SerialDispatchQueue同时只能执行一个追加处理
ConcurrentDispatchQueue并行执行多个追加处理
虽然SerialDispatchQueue ConcurrentDispatchQueue受到系统资源的限制，但是用dispatch_queue_create可以生成任意多个Dispatch Queue
当生成多个SerialDispatchQueue时，各个SerialDispatchQueue将并行执行，虽然一个SerialDispatchQueue同时只能执行一个追加处理，但是如果将处理分别追加到4个
Serial Dispatch Queue中，各个Serial Dispatch Queue执行一个，即为同时执行4个处理
但是生成Serial Dispatch Queue的个数受系统限制
为了避免多线程编程的问题之一---数据竞争，就可以使用Serial Dispatch Queue。
当想并行执行且不发生数据竞争等问题时就应该使用Concurrent Dispatch Queue。
[cpp]
//以下代码是两种生成Serial Dispatch Queue的方式
dispatch_queue_t mySerialDispatchQueue = dispatch_queue_create("cn.edu.scnu.mySerialDispatchQueue", NULL);
// dispatch_queue_t mySerialDispatchQueue = dispatch_queue_create("cn.edu.scnu.mySerialDispatchQueue", DISPATCH_QUEUE_SERIAL);
//以下代码是两种生成Serial Dispatch Queue的方式
dispatch_queue_t mySerialDispatchQueue = dispatch_queue_create("cn.edu.scnu.mySerialDispatchQueue", NULL);
// dispatch_queue_t mySerialDispatchQueue = dispatch_queue_create("cn.edu.scnu.mySerialDispatchQueue", DISPATCH_QUEUE_SERIAL);
dispatch_queue_create,该方法中的第一个参数指定SerialDispatchQueue的名称，DispatchQueue的名称推荐使用应用程序ID之中逆序全程域名，第二个参数指定为NULL（或者DISPATCH_QUEUE_SERIAL）时即表示生成的是Serial Dispatch Queue,指定为DISPATCH_QUEUE_CONCURRENT时即表示生成的是Concurrent Dispatch Queue
[cpp]
//以下代码生成ConcurrentDispatchQueue
dispatch_queue_t myConcurrentDispatchQueue = dispatch_queue_create("cn.edu.scnu.myConcurrentDispatchQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(myConcurrentDispatchQueue, ^{
NSLog(@"block on my ConcurrentDispatchQueue");
});
//以下代码生成ConcurrentDispatchQueue
dispatch_queue_t myConcurrentDispatchQueue = dispatch_queue_create("cn.edu.scnu.myConcurrentDispatchQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(myConcurrentDispatchQueue, ^{
NSLog(@"block on my ConcurrentDispatchQueue");
});
2、MainDispatch Queue 和 Global Dispatch Queue
实际上不用特意生成DispatchQueue，系统也会提供几个给我们，就是Main DispatchQueue 和 Global Dispatch Queue
Main Dispatch Queue就是主线程中执行的Dispatch Queue，因为主线程只有一个，所以Main DispatchQueue自然就是 Serial Dispatch Queue
[cpp]
//获取Main Dispatch Queue
dispatch_queue_t mainDispatchQueue = dispatch_get_main_queue();
//获取Main Dispatch Queue
dispatch_queue_t mainDispatchQueue = dispatch_get_main_queue();
GlobalDispatch Queue是所有应用程序都能够使用的Concurrent Dispatch Queue，没有必要通过dispatch_queue_create方法逐个生成Concurrent Dispatch Queue，只要获
取GlobalDispatch Queue使用即可。
Global Dispatch Queue有四个优先级：High Priority,Default Priority,Low Priority,Background Priority
[cpp]
//获取高优先级的的Global Dispatch Queue
/*
DISPATCH_QUEUE_PRIORITY_HIGH
DISPATCH_QUEUE_PRIORITY_DEFAULT
DISPATCH_QUEUE_PRIORITY_LOW
DISPATCH_QUEUE_PRIORITY_BACKGROUND
*/
dispatch_queue_t globalDispatchQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
//第一个参数指定Global Dispatch Queue的优先级，第二个参数指定为0
//获取高优先级的的Global Dispatch Queue
/*
DISPATCH_QUEUE_PRIORITY_HIGH
DISPATCH_QUEUE_PRIORITY_DEFAULT
DISPATCH_QUEUE_PRIORITY_LOW
DISPATCH_QUEUE_PRIORITY_BACKGROUND
*/
dispatch_queue_t globalDispatchQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
//第一个参数指定Global Dispatch Queue的优先级，第二个参数指定为0
3、dispatch_set_target_queue
dispatch_queue_create函数生成的Dispatch Queue不管是Serial Dispatch Queue还是Concurrent Dispatch Queue，都是使用与默认优先级的Global Dispatch Queue相同执
行优先级的线程
如果想变更生成的Dispatch Queue的执行优先级要使用dispatch_set_target_queue方法。
[cpp]
dispatch_queue_t mySerialDispatchQueue = dispatch_queue_create("cn.edu.scnu.mySerialDispatchQueue", NULL);
dispatch_queue_t globalDispatchQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_set_target_queue(mySerialDispatchQueue, globalDispatchQueue);
//指定要变更执行优先级的dispatch queue为dispatch_set_target_queue方法的第一个参数，指定与要使用的执行优先级相同优先级的Global Dispatch Queue为第二个参数（目标）
//第一个参数不可以指定为系统提供的Main Dispatch Queue 和 Global Dispatch Queue
dispatch_queue_t mySerialDispatchQueue = dispatch_queue_create("cn.edu.scnu.mySerialDispatchQueue", NULL);
dispatch_queue_t globalDispatchQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_set_target_queue(mySerialDispatchQueue, globalDispatchQueue);
//指定要变更执行优先级的dispatch queue为dispatch_set_target_queue方法的第一个参数，指定与要使用的执行优先级相同优先级的Global Dispatch Queue为第二个参数（目标）
//第一个参数不可以指定为系统提供的Main Dispatch Queue 和 Global Dispatch Queue
4、dispatch_after
想在指定时间后执行处理的情况，可以使用 dispatch_after 方法来实现
[cpp]
double delayInSeconds = 2.0;
dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delayInSeconds * NSEC_PER_SEC));
dispatch_after(popTime, dispatch_get_main_queue(), ^(void){
NSLog(@"waited at least 2.0 seconds.");
});
double delayInSeconds = 2.0;
dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delayInSeconds * NSEC_PER_SEC));
dispatch_after(popTime, dispatch_get_main_queue(), ^(void){
NSLog(@"waited at least 2.0 seconds.");
});
值得注意的是，dispatch_after方法并不是在指定时间后执行处理任务，而是在指定时间后追加处理到dispatch queue中，上面的代码在2秒后用dispatch_after方法追加
block到Main Dispatch Queue中，因为Main Dispatch Queue在主线程的RunLoop中执行，所以比如每个1/60秒执行的RunLoop中，Block最快在2秒后执行，最慢在2秒+1/60
秒后执行，而且在Main Dispatch Queue中又大量处理追加或者主线程的处理本身有延时时，这个时间会更长。
dispatch_after这个方法的第二个参数指定要追加的dispatch queue，第三个参数指定要执行处理的Block，第一个参数是指定时间用的dispatch_time_t类型的值，在使用
dispatch_after的时候，编译器会自动帮你生成这些代码，只需修改delayInSeconds就可以了。
5、Dispatch Group
在追加到dispatch queue中的多个处理全部结束后想执行结束处理任务，这种情况会经常出现。只使用一个Serial Dispatch Queue时，只要将想执行的全部处理都追加到该
Serial Dispatch Queue种并在最后追加结束处理就可以实现。但是在使用Concurrent Dispatch Queue时或者同时使用多个dispatch queue时，就会有些复杂了，在这种情况下
就应该使用Dispatch Group
[cpp]
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, queue, ^{NSLog(@"blk1");});
dispatch_group_async(group, queue, ^{NSLog(@"blk2");});
dispatch_group_async(group, queue, ^{NSLog(@"blk3");});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
NSLog(@"done");
});
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, queue, ^{NSLog(@"blk1");});
dispatch_group_async(group, queue, ^{NSLog(@"blk2");});
dispatch_group_async(group, queue, ^{NSLog(@"blk3");});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
NSLog(@"done");
});
因为向 Global Dispatch Queue即Concurrent Dispatch Queue追加处理任务，多个线程并行执行，所以追加处理任务的执行顺序是不定的，执行时顺序会发生变化，但是主线程中执行结果输出done肯定是最后的。
下面稍微解释一下上面的那段代码，上面由3个输出任务的block组成一个dispatch group，并把这个dispatch group添加到dispatch queue中执行，当dispatch group中的
block任务执行完毕后，dispatch_group_notify方法就会被执行到，所以它的第一个参数是group，表示其被监视。在追加到dispatch group中的全部执行处理任务执行结束后，
将第三个参数中的block任务添加到第二个参数的dispatch queue中执行，注意此时dispatch group中的所以执行任务已经执行结束了。
另外，在dispatch group中也可以使用 dispatch_group_wait方法仅等待全部处理执行结束。
[cpp]
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, queue, ^{NSLog(@"blk1");});
dispatch_group_async(group, queue, ^{NSLog(@"blk2");});
dispatch_group_async(group, queue, ^{NSLog(@"blk3");});
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, queue, ^{NSLog(@"blk1");});
dispatch_group_async(group, queue, ^{NSLog(@"blk2");});
dispatch_group_async(group, queue, ^{NSLog(@"blk3");});
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
在这个方法中的第二个参数指定等待时间，这里使用DISPATCH_TIME_FOREVER意味着永久等待，只要属于dispatch group中的处理尚未执行结束，就会一直等待，中途不能取消。
当然如同dispatch——after方法中那样，也可以指定等待时间为1秒等等。
[cpp]
//这里指定等待时间1s，即1s后查看dispatch group中的处理是否全部执行结束
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 1ull*NSEC_PER_SEC);
long result = dispatch_group_wait(group, time);
if (result == 0) {
//属于dispatch group中的全部处理都执行结束
}
else {
//属于dispatch group的某一个处理还在执行
}
//这里指定等待时间1s，即1s后查看dispatch group中的处理是否全部执行结束
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 1ull*NSEC_PER_SEC);
long result = dispatch_group_wait(group, time);
if (result == 0) {
//属于dispatch group中的全部处理都执行结束
}
else {
//属于dispatch group的某一个处理还在执行
}
[cpp]
//这里也可以指定DISPATCH_TIME_NOW,则不用任何等待即可判断属于dispatch group中的处理是否全部执行结束
long result = dispatch_group_wait(group, DISPATCH_TIME_NOW);
//这里也可以指定DISPATCH_TIME_NOW,则不用任何等待即可判断属于dispatch group中的处理是否全部执行结束
long result = dispatch_group_wait(group, DISPATCH_TIME_NOW);
6、dispatch_barrier_async
[cpp]
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_async(queue, ^{
//表示执行数据读取任务
NSLog(@"blk1_reading");
});
dispatch_async(queue, ^{
NSLog(@"blk2_reading");
});
dispatch_async(queue, ^{
//表示执行数据写入处理任务
NSLog(@"blk1_writting");
});
dispatch_async(queue, ^{
NSLog(@"blk3_reading");
});
dispatch_async(queue, ^{
NSLog(@"blk4_reading");
});
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_async(queue, ^{
//表示执行数据读取任务
NSLog(@"blk1_reading");
});
dispatch_async(queue, ^{
NSLog(@"blk2_reading");
});
dispatch_async(queue, ^{
//表示执行数据写入处理任务
NSLog(@"blk1_writting");
});
dispatch_async(queue, ^{
NSLog(@"blk3_reading");
});
dispatch_async(queue, ^{
NSLog(@"blk4_reading");
});
如果像上面那样简单的在dispatch_async方法中添加写入数据处理的任务，那么根据Concurrent Dispatch Queue并行执行的性质，就很有可能不是按照上面的添加处理任务的
顺序执行，那么在blk3_reading 和 blk4_reading执行读取数据的时候，blk1_writting进行写入数据的处理还没有执行到，那么后两次的读取数据操作读取到的数据就与期望中
的不符了。
解决这个问题的处理就是 使用 dispatch_barrier_async
[cpp]
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_async(queue, ^{
//表示执行数据读取任务
NSLog(@"blk1_reading");
});
dispatch_async(queue, ^{
NSLog(@"blk2_reading");
});
dispatch_barrier_async(queue, ^{
//表示执行数据写入处理任务
NSLog(@"blk1_writting");
});
dispatch_async(queue, ^{
NSLog(@"blk3_reading");
});
dispatch_async(queue, ^{
NSLog(@"blk4_reading");
});
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_async(queue, ^{
//表示执行数据读取任务
NSLog(@"blk1_reading");
});
dispatch_async(queue, ^{
NSLog(@"blk2_reading");
});
dispatch_barrier_async(queue, ^{
//表示执行数据写入处理任务
NSLog(@"blk1_writting");
});
dispatch_async(queue, ^{
NSLog(@"blk3_reading");
});
dispatch_async(queue, ^{
NSLog(@"blk4_reading");
});
使用dispatch_barrier_async方法，它会等待在它之前添加到 Concurrent Dispatch Queue的所有处理执行结束后，才执行该处理，然后等待该处理结束后，才接着处理后续添
加到Concurrent Dispatch Queue中的处理任务。当然在dispatch_barrier_async方法之前和之后添加的处理任务可以并发执行，即不保证执行顺序，但是可以确保
dispatch_barrier_async方法添加的任务一定是只能同时执行一个，按其添加任务顺序执行的，就是说，执行完blk1_reading和blk2_reading的读取数据任务后，才是进行
blk1_writting的写入数据任务，然后才是执行接着的读取数据的任务。
7、dispatch——sync
dispatch_async方法中的async意味着“非同步”，就是将指定的block非同步的添加到dispatch qeueue中，dispatch_async方法不做任何等待。
dispatch_sync方法中的sync意味着“同步”，也就是将指定的block同步追加到dispatch queue中，在追加block的过程结束之前，dispatch_sync方法会一直等待。
一旦调用dispatch_sync，那么在指定的处理执行结束之前，该方法不会返回，dispatch_sync方法可以简化代码，也可以说是简易版的dispatch_group_wait方法
dispatch_sync方法使用简单，但是容易引起死锁
[cpp]
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_sync(queue, ^{
NSLog(@"引起死锁！");
});
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_sync(queue, ^{
NSLog(@"引起死锁！");
});
上面的代码在主线程中执行指定的block，并等待其执行结束，但是其实在主线程中就是在执行这些代码，所以就造成了死锁。
8、dispatch_apply
dispatch_apply 方法是 dispatch_sync 方法和Dispatch Group的关联API，该方法按指定的次数将指定的Block追加到指定的Dispatch Queue中，并等待全部处理执行结束
[cpp]
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_apply(10, queue, ^(size_t index){
NSLog(@"%zu",index);
});
NSLog(@"done");
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_apply(10, queue, ^(size_t index){
NSLog(@"%zu",index);
});
NSLog(@"done");
因为是在Global Dispatch Queue中执行处理，所以各个处理的执行时间不定，也就是说输出1 2 3 ...的顺序不定。但是输出结果done必定是在最后的位置上的。因为dispatch_apply会等待所以的处理任务执行结束。
dispatch_apply 中的第一个参数是重复次数，第二个参数是追加对象的Dispatch Queue，第三个参数为追加的处理block，注意带参数
[cpp]
//假如对一个NSArray类对象的所有元素执行处理时，不必一个个编写for循环
NSArray *array = [[NSArray alloc] initWithObjects:@"string1",@"string2",@"string3", nil];
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_apply([array count], queue, ^(size_t index){
NSLog(@"%zu : %@",index,[array objectAtIndex:index]);
});
//假如对一个NSArray类对象的所有元素执行处理时，不必一个个编写for循环
NSArray *array = [[NSArray alloc] initWithObjects:@"string1",@"string2",@"string3", nil];
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_apply([array count], queue, ^(size_t index){
NSLog(@"%zu : %@",index,[array objectAtIndex:index]);
});
由于dispatch_apply方法也与dispatch_sync方法相同，会等待处理执行结束，因此推荐在dispatch_async函数中非同步的执行dispatch_apply方法。
例如：
[cpp]
NSArray *array = [[NSArray alloc] initWithObjects:@"string1",@"string2",@"string3", nil];
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//在Glocbal Dispatch Queue中非同步执行
dispatch_async(queue, ^{
//等待dispatch_apply方法中的全部处理执行结束
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_apply([array count], queue, ^(size_t index){
NSLog(@"%zu : %@",index,[array objectAtIndex:index]);
});
//dispatch_apply方法中的全部处理任务执行结束
dispatch_async(dispatch_get_main_queue(), ^{
//在主线程中执行处理
NSLog(@"done");
});
});
NSArray *array = [[NSArray alloc] initWithObjects:@"string1",@"string2",@"string3", nil];
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//在Glocbal Dispatch Queue中非同步执行
dispatch_async(queue, ^{
//等待dispatch_apply方法中的全部处理执行结束
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_apply([array count], queue, ^(size_t index){
NSLog(@"%zu : %@",index,[array objectAtIndex:index]);
});
//dispatch_apply方法中的全部处理任务执行结束
dispatch_async(dispatch_get_main_queue(), ^{
//在主线程中执行处理
NSLog(@"done");
});
});
9、dispatch_suspend 和 dispatch_resume
[cpp]
//挂起指定的dispatch queue
dispatch_suspend(<#dispatch_object_t object#>)
//恢复指定的dispatch queue
dispatch_resume(<#dispatch_object_t object#>)
//这些方法对已经执行的处理没有影响，挂起后，追加到dispatch queue中但尚未处理的在此之后停止执行，而恢复后则使得这些处理能够继续执行。
//挂起指定的dispatch queue
dispatch_suspend(<#dispatch_object_t object#>)
//恢复指定的dispatch queue
dispatch_resume(<#dispatch_object_t object#>)
//这些方法对已经执行的处理没有影响，挂起后，追加到dispatch queue中但尚未处理的在此之后停止执行，而恢复后则使得这些处理能够继续执行。
10、dispatch_once
dispatch_once方法保证在应用程序执行中只执行一次指定处理的API。
[cpp]
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
//code to be executed once
});
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
//code to be executed once
});
开发者只需要定义想要执行的任务并追加到适当的Dispatch Queue中，GCD就能生成必要的线程并计划执行任务。
二、多线程编程
由于使用多线程的程序可以在某个线程和其他线程之间反复多次进行上下文切换，因此看上去就好像一个CPU核能够并行的执行多个线程一样，而且在具有多个CPU核的情况下，就不是“看上去像”了，而是真的提供了多个CPU核并行执行任务的多个线程的技术。
多线程编程容易发生各种编程问题：比如多个线程更新相同的资源会导致数据的不一致（数据竞争）、停止等待事件的线程会导致多个线程相互持续等待（死锁）、使用太多线程会消耗大量的内存资源等等。
尽管会有问题，但是为什么还要用呢？
在应用程序启动时，通过最先执行的线程，即主线程来描绘用户界面、处理用户触摸事件等，但是如果在该主线程中进行长时间的处理，就会妨碍主线程中被称为RunLoop的主循环的执行，从而导致不能跟新用户界面，应用程序的画面长时间停滞等问题。
三、GCD 的 API
1.Dispatch Queue
开发者要做的只是定义想要执行的任务并追加到适当的DispatchQueue中。
在Block中定义想要执行的任务，然后追加到Dispatch Queue中
Dispatch Queue是执行处理的等待队列，通过dispatch_async等API，在Block语法中记叙想要执行的处理并将其追加到Dispatch Queue中，Dispatch Queue按照追加的顺序（FIFO）执行处理。
另外，在执行处理时存在两种Dispatch Queue：
Dispatch Queue的种类
说明
Serial Dispatch Queue
等待现在执行中处理结束
Concurrent Dispatch Queue
不等待现在执行中处理结束
解释说明一下：
（1） Serial Dispatch Queue：就是要等待现在执行中处理结束后才可以进行下一个任务的执行处理，假如现在有blk1，blk2，blk3，在Serial Dispatch Queue中，那么同时执行处理数只能是一个，而且按按添加顺序FIFO进行处理，即先执行blk1，执行结束后再执行blk2，执行结束再进行blk3的执行。
（2） Concurrent Dispatch Queue：就是一个线程的执行不等待现在（当前）执行中的任务处理结束就可以开始另一个任务的执行处理。同样假如有blk1，blk2，blk3在Concurrent Dispatch Queue中，那么首先执行blk1，不管blk1是否执行处理结束，都开始执行后面的blk2，不管blk2是否执行结束，都开始执行后面的blk2。
这样虽然不用等待处理结束，可以并行执行多个任务处理，但是并行处理数取决于当前系统的状态，有它决定Concurrent Dispatch Queue中并行执行的处理数。所谓并行执行就是使用多个线程来同时执行多个处理任务（block中的执行任务）。
SerialDispatchQueue同时只能执行一个追加处理
ConcurrentDispatchQueue并行执行多个追加处理
虽然SerialDispatchQueue ConcurrentDispatchQueue受到系统资源的限制，但是用dispatch_queue_create可以生成任意多个Dispatch Queue
当生成多个SerialDispatchQueue时，各个SerialDispatchQueue将并行执行，虽然一个SerialDispatchQueue同时只能执行一个追加处理，但是如果将处理分别追加到4个
Serial Dispatch Queue中，各个Serial Dispatch Queue执行一个，即为同时执行4个处理
但是生成Serial Dispatch Queue的个数受系统限制
为了避免多线程编程的问题之一---数据竞争，就可以使用Serial Dispatch Queue。
当想并行执行且不发生数据竞争等问题时就应该使用Concurrent Dispatch Queue。
[cpp]
//以下代码是两种生成Serial Dispatch Queue的方式
dispatch_queue_t mySerialDispatchQueue = dispatch_queue_create("cn.edu.scnu.mySerialDispatchQueue", NULL);
// dispatch_queue_t mySerialDispatchQueue = dispatch_queue_create("cn.edu.scnu.mySerialDispatchQueue", DISPATCH_QUEUE_SERIAL);
//以下代码是两种生成Serial Dispatch Queue的方式
dispatch_queue_t mySerialDispatchQueue = dispatch_queue_create("cn.edu.scnu.mySerialDispatchQueue", NULL);
// dispatch_queue_t mySerialDispatchQueue = dispatch_queue_create("cn.edu.scnu.mySerialDispatchQueue", DISPATCH_QUEUE_SERIAL);
dispatch_queue_create,该方法中的第一个参数指定SerialDispatchQueue的名称，DispatchQueue的名称推荐使用应用程序ID之中逆序全程域名，第二个参数指定为NULL（或者DISPATCH_QUEUE_SERIAL）时即表示生成的是Serial Dispatch Queue,指定为DISPATCH_QUEUE_CONCURRENT时即表示生成的是Concurrent Dispatch Queue
[cpp]
//以下代码生成ConcurrentDispatchQueue
dispatch_queue_t myConcurrentDispatchQueue = dispatch_queue_create("cn.edu.scnu.myConcurrentDispatchQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(myConcurrentDispatchQueue, ^{
NSLog(@"block on my ConcurrentDispatchQueue");
});
//以下代码生成ConcurrentDispatchQueue
dispatch_queue_t myConcurrentDispatchQueue = dispatch_queue_create("cn.edu.scnu.myConcurrentDispatchQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(myConcurrentDispatchQueue, ^{
NSLog(@"block on my ConcurrentDispatchQueue");
});
2、MainDispatch Queue 和 Global Dispatch Queue
实际上不用特意生成DispatchQueue，系统也会提供几个给我们，就是Main DispatchQueue 和 Global Dispatch Queue
Main Dispatch Queue就是主线程中执行的Dispatch Queue，因为主线程只有一个，所以Main DispatchQueue自然就是 Serial Dispatch Queue
[cpp]
//获取Main Dispatch Queue
dispatch_queue_t mainDispatchQueue = dispatch_get_main_queue();
//获取Main Dispatch Queue
dispatch_queue_t mainDispatchQueue = dispatch_get_main_queue();
GlobalDispatch Queue是所有应用程序都能够使用的Concurrent Dispatch Queue，没有必要通过dispatch_queue_create方法逐个生成Concurrent Dispatch Queue，只要获
取GlobalDispatch Queue使用即可。
Global Dispatch Queue有四个优先级：High Priority,Default Priority,Low Priority,Background Priority
[cpp]
//获取高优先级的的Global Dispatch Queue
/*
DISPATCH_QUEUE_PRIORITY_HIGH
DISPATCH_QUEUE_PRIORITY_DEFAULT
DISPATCH_QUEUE_PRIORITY_LOW
DISPATCH_QUEUE_PRIORITY_BACKGROUND
*/
dispatch_queue_t globalDispatchQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
//第一个参数指定Global Dispatch Queue的优先级，第二个参数指定为0
//获取高优先级的的Global Dispatch Queue
/*
DISPATCH_QUEUE_PRIORITY_HIGH
DISPATCH_QUEUE_PRIORITY_DEFAULT
DISPATCH_QUEUE_PRIORITY_LOW
DISPATCH_QUEUE_PRIORITY_BACKGROUND
*/
dispatch_queue_t globalDispatchQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
//第一个参数指定Global Dispatch Queue的优先级，第二个参数指定为0
3、dispatch_set_target_queue
dispatch_queue_create函数生成的Dispatch Queue不管是Serial Dispatch Queue还是Concurrent Dispatch Queue，都是使用与默认优先级的Global Dispatch Queue相同执
行优先级的线程
如果想变更生成的Dispatch Queue的执行优先级要使用dispatch_set_target_queue方法。
[cpp]
dispatch_queue_t mySerialDispatchQueue = dispatch_queue_create("cn.edu.scnu.mySerialDispatchQueue", NULL);
dispatch_queue_t globalDispatchQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_set_target_queue(mySerialDispatchQueue, globalDispatchQueue);
//指定要变更执行优先级的dispatch queue为dispatch_set_target_queue方法的第一个参数，指定与要使用的执行优先级相同优先级的Global Dispatch Queue为第二个参数（目标）
//第一个参数不可以指定为系统提供的Main Dispatch Queue 和 Global Dispatch Queue
dispatch_queue_t mySerialDispatchQueue = dispatch_queue_create("cn.edu.scnu.mySerialDispatchQueue", NULL);
dispatch_queue_t globalDispatchQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_set_target_queue(mySerialDispatchQueue, globalDispatchQueue);
//指定要变更执行优先级的dispatch queue为dispatch_set_target_queue方法的第一个参数，指定与要使用的执行优先级相同优先级的Global Dispatch Queue为第二个参数（目标）
//第一个参数不可以指定为系统提供的Main Dispatch Queue 和 Global Dispatch Queue
4、dispatch_after
想在指定时间后执行处理的情况，可以使用 dispatch_after 方法来实现
[cpp]
double delayInSeconds = 2.0;
dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delayInSeconds * NSEC_PER_SEC));
dispatch_after(popTime, dispatch_get_main_queue(), ^(void){
NSLog(@"waited at least 2.0 seconds.");
});
double delayInSeconds = 2.0;
dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delayInSeconds * NSEC_PER_SEC));
dispatch_after(popTime, dispatch_get_main_queue(), ^(void){
NSLog(@"waited at least 2.0 seconds.");
});
值得注意的是，dispatch_after方法并不是在指定时间后执行处理任务，而是在指定时间后追加处理到dispatch queue中，上面的代码在2秒后用dispatch_after方法追加
block到Main Dispatch Queue中，因为Main Dispatch Queue在主线程的RunLoop中执行，所以比如每个1/60秒执行的RunLoop中，Block最快在2秒后执行，最慢在2秒+1/60
秒后执行，而且在Main Dispatch Queue中又大量处理追加或者主线程的处理本身有延时时，这个时间会更长。
dispatch_after这个方法的第二个参数指定要追加的dispatch queue，第三个参数指定要执行处理的Block，第一个参数是指定时间用的dispatch_time_t类型的值，在使用
dispatch_after的时候，编译器会自动帮你生成这些代码，只需修改delayInSeconds就可以了。
5、Dispatch Group
在追加到dispatch queue中的多个处理全部结束后想执行结束处理任务，这种情况会经常出现。只使用一个Serial Dispatch Queue时，只要将想执行的全部处理都追加到该
Serial Dispatch Queue种并在最后追加结束处理就可以实现。但是在使用Concurrent Dispatch Queue时或者同时使用多个dispatch queue时，就会有些复杂了，在这种情况下
就应该使用Dispatch Group
[cpp]
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, queue, ^{NSLog(@"blk1");});
dispatch_group_async(group, queue, ^{NSLog(@"blk2");});
dispatch_group_async(group, queue, ^{NSLog(@"blk3");});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
NSLog(@"done");
});
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, queue, ^{NSLog(@"blk1");});
dispatch_group_async(group, queue, ^{NSLog(@"blk2");});
dispatch_group_async(group, queue, ^{NSLog(@"blk3");});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
NSLog(@"done");
});
因为向 Global Dispatch Queue即Concurrent Dispatch Queue追加处理任务，多个线程并行执行，所以追加处理任务的执行顺序是不定的，执行时顺序会发生变化，但是主线程中执行结果输出done肯定是最后的。
下面稍微解释一下上面的那段代码，上面由3个输出任务的block组成一个dispatch group，并把这个dispatch group添加到dispatch queue中执行，当dispatch group中的
block任务执行完毕后，dispatch_group_notify方法就会被执行到，所以它的第一个参数是group，表示其被监视。在追加到dispatch group中的全部执行处理任务执行结束后，
将第三个参数中的block任务添加到第二个参数的dispatch queue中执行，注意此时dispatch group中的所以执行任务已经执行结束了。
另外，在dispatch group中也可以使用 dispatch_group_wait方法仅等待全部处理执行结束。
[cpp]
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, queue, ^{NSLog(@"blk1");});
dispatch_group_async(group, queue, ^{NSLog(@"blk2");});
dispatch_group_async(group, queue, ^{NSLog(@"blk3");});
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, queue, ^{NSLog(@"blk1");});
dispatch_group_async(group, queue, ^{NSLog(@"blk2");});
dispatch_group_async(group, queue, ^{NSLog(@"blk3");});
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
在这个方法中的第二个参数指定等待时间，这里使用DISPATCH_TIME_FOREVER意味着永久等待，只要属于dispatch group中的处理尚未执行结束，就会一直等待，中途不能取消。
当然如同dispatch——after方法中那样，也可以指定等待时间为1秒等等。
[cpp]
//这里指定等待时间1s，即1s后查看dispatch group中的处理是否全部执行结束
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 1ull*NSEC_PER_SEC);
long result = dispatch_group_wait(group, time);
if (result == 0) {
//属于dispatch group中的全部处理都执行结束
}
else {
//属于dispatch group的某一个处理还在执行
}
//这里指定等待时间1s，即1s后查看dispatch group中的处理是否全部执行结束
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 1ull*NSEC_PER_SEC);
long result = dispatch_group_wait(group, time);
if (result == 0) {
//属于dispatch group中的全部处理都执行结束
}
else {
//属于dispatch group的某一个处理还在执行
}
[cpp]
//这里也可以指定DISPATCH_TIME_NOW,则不用任何等待即可判断属于dispatch group中的处理是否全部执行结束
long result = dispatch_group_wait(group, DISPATCH_TIME_NOW);
//这里也可以指定DISPATCH_TIME_NOW,则不用任何等待即可判断属于dispatch group中的处理是否全部执行结束
long result = dispatch_group_wait(group, DISPATCH_TIME_NOW);
6、dispatch_barrier_async
[cpp]
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_async(queue, ^{
//表示执行数据读取任务
NSLog(@"blk1_reading");
});
dispatch_async(queue, ^{
NSLog(@"blk2_reading");
});
dispatch_async(queue, ^{
//表示执行数据写入处理任务
NSLog(@"blk1_writting");
});
dispatch_async(queue, ^{
NSLog(@"blk3_reading");
});
dispatch_async(queue, ^{
NSLog(@"blk4_reading");
});
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_async(queue, ^{
//表示执行数据读取任务
NSLog(@"blk1_reading");
});
dispatch_async(queue, ^{
NSLog(@"blk2_reading");
});
dispatch_async(queue, ^{
//表示执行数据写入处理任务
NSLog(@"blk1_writting");
});
dispatch_async(queue, ^{
NSLog(@"blk3_reading");
});
dispatch_async(queue, ^{
NSLog(@"blk4_reading");
});
如果像上面那样简单的在dispatch_async方法中添加写入数据处理的任务，那么根据Concurrent Dispatch Queue并行执行的性质，就很有可能不是按照上面的添加处理任务的
顺序执行，那么在blk3_reading 和 blk4_reading执行读取数据的时候，blk1_writting进行写入数据的处理还没有执行到，那么后两次的读取数据操作读取到的数据就与期望中
的不符了。
解决这个问题的处理就是 使用 dispatch_barrier_async
[cpp]
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_async(queue, ^{
//表示执行数据读取任务
NSLog(@"blk1_reading");
});
dispatch_async(queue, ^{
NSLog(@"blk2_reading");
});
dispatch_barrier_async(queue, ^{
//表示执行数据写入处理任务
NSLog(@"blk1_writting");
});
dispatch_async(queue, ^{
NSLog(@"blk3_reading");
});
dispatch_async(queue, ^{
NSLog(@"blk4_reading");
});
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_async(queue, ^{
//表示执行数据读取任务
NSLog(@"blk1_reading");
});
dispatch_async(queue, ^{
NSLog(@"blk2_reading");
});
dispatch_barrier_async(queue, ^{
//表示执行数据写入处理任务
NSLog(@"blk1_writting");
});
dispatch_async(queue, ^{
NSLog(@"blk3_reading");
});
dispatch_async(queue, ^{
NSLog(@"blk4_reading");
});
使用dispatch_barrier_async方法，它会等待在它之前添加到 Concurrent Dispatch Queue的所有处理执行结束后，才执行该处理，然后等待该处理结束后，才接着处理后续添
加到Concurrent Dispatch Queue中的处理任务。当然在dispatch_barrier_async方法之前和之后添加的处理任务可以并发执行，即不保证执行顺序，但是可以确保
dispatch_barrier_async方法添加的任务一定是只能同时执行一个，按其添加任务顺序执行的，就是说，执行完blk1_reading和blk2_reading的读取数据任务后，才是进行
blk1_writting的写入数据任务，然后才是执行接着的读取数据的任务。
7、dispatch——sync
dispatch_async方法中的async意味着“非同步”，就是将指定的block非同步的添加到dispatch qeueue中，dispatch_async方法不做任何等待。
dispatch_sync方法中的sync意味着“同步”，也就是将指定的block同步追加到dispatch queue中，在追加block的过程结束之前，dispatch_sync方法会一直等待。
一旦调用dispatch_sync，那么在指定的处理执行结束之前，该方法不会返回，dispatch_sync方法可以简化代码，也可以说是简易版的dispatch_group_wait方法
dispatch_sync方法使用简单，但是容易引起死锁
[cpp]
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_sync(queue, ^{
NSLog(@"引起死锁！");
});
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_sync(queue, ^{
NSLog(@"引起死锁！");
});
上面的代码在主线程中执行指定的block，并等待其执行结束，但是其实在主线程中就是在执行这些代码，所以就造成了死锁。
8、dispatch_apply
dispatch_apply 方法是 dispatch_sync 方法和Dispatch Group的关联API，该方法按指定的次数将指定的Block追加到指定的Dispatch Queue中，并等待全部处理执行结束
[cpp]
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_apply(10, queue, ^(size_t index){
NSLog(@"%zu",index);
});
NSLog(@"done");
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_apply(10, queue, ^(size_t index){
NSLog(@"%zu",index);
});
NSLog(@"done");
因为是在Global Dispatch Queue中执行处理，所以各个处理的执行时间不定，也就是说输出1 2 3 ...的顺序不定。但是输出结果done必定是在最后的位置上的。因为dispatch_apply会等待所以的处理任务执行结束。
dispatch_apply 中的第一个参数是重复次数，第二个参数是追加对象的Dispatch Queue，第三个参数为追加的处理block，注意带参数
[cpp]
//假如对一个NSArray类对象的所有元素执行处理时，不必一个个编写for循环
NSArray *array = [[NSArray alloc] initWithObjects:@"string1",@"string2",@"string3", nil];
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_apply([array count], queue, ^(size_t index){
NSLog(@"%zu : %@",index,[array objectAtIndex:index]);
});
//假如对一个NSArray类对象的所有元素执行处理时，不必一个个编写for循环
NSArray *array = [[NSArray alloc] initWithObjects:@"string1",@"string2",@"string3", nil];
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_apply([array count], queue, ^(size_t index){
NSLog(@"%zu : %@",index,[array objectAtIndex:index]);
});
由于dispatch_apply方法也与dispatch_sync方法相同，会等待处理执行结束，因此推荐在dispatch_async函数中非同步的执行dispatch_apply方法。
例如：
[cpp]
NSArray *array = [[NSArray alloc] initWithObjects:@"string1",@"string2",@"string3", nil];
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//在Glocbal Dispatch Queue中非同步执行
dispatch_async(queue, ^{
//等待dispatch_apply方法中的全部处理执行结束
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_apply([array count], queue, ^(size_t index){
NSLog(@"%zu : %@",index,[array objectAtIndex:index]);
});
//dispatch_apply方法中的全部处理任务执行结束
dispatch_async(dispatch_get_main_queue(), ^{
//在主线程中执行处理
NSLog(@"done");
});
});
NSArray *array = [[NSArray alloc] initWithObjects:@"string1",@"string2",@"string3", nil];
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//在Glocbal Dispatch Queue中非同步执行
dispatch_async(queue, ^{
//等待dispatch_apply方法中的全部处理执行结束
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_apply([array count], queue, ^(size_t index){
NSLog(@"%zu : %@",index,[array objectAtIndex:index]);
});
//dispatch_apply方法中的全部处理任务执行结束
dispatch_async(dispatch_get_main_queue(), ^{
//在主线程中执行处理
NSLog(@"done");
});
});
9、dispatch_suspend 和 dispatch_resume
[cpp]
//挂起指定的dispatch queue
dispatch_suspend(<#dispatch_object_t object#>)
//恢复指定的dispatch queue
dispatch_resume(<#dispatch_object_t object#>)
//这些方法对已经执行的处理没有影响，挂起后，追加到dispatch queue中但尚未处理的在此之后停止执行，而恢复后则使得这些处理能够继续执行。
//挂起指定的dispatch queue
dispatch_suspend(<#dispatch_object_t object#>)
//恢复指定的dispatch queue
dispatch_resume(<#dispatch_object_t object#>)
//这些方法对已经执行的处理没有影响，挂起后，追加到dispatch queue中但尚未处理的在此之后停止执行，而恢复后则使得这些处理能够继续执行。
10、dispatch_once
dispatch_once方法保证在应用程序执行中只执行一次指定处理的API。
[cpp]
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
//code to be executed once
});
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
//code to be executed once
});
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- iOS开发技巧--使用CocoaPods创建、删除第三方框架
- Cordova for iOS[ PhoneGap]
- iOS富文本（三）深入使用Text Kit
- iOS富文本（三）深入使用Text Kit
- iOS内存管理笔记 by STP
- OSX 10.10+Xcode5.1 无法启动或者安装应用程序到iOS 6.1 simulator
- 03-加入苹果开发者计划
- iOS委托理解
- IOS多线程
- iOS runtime原理
- ios runtime
- IOS-TableView 方法
- iOS 8 新特性总结
- iOS 9开发（适配）中需要注意的事项总结
- iOS 动画
- ios 获取屏幕的属性和宽度
- 如何让iOS 保持界面流畅？这些技巧你知道吗
- （十四）关于#include<iostream>
- IOS的一些手势方法(手势的tag值 绝对值 偏移量 中心点 等等)
- iOS 音频