dispatch_async
两个异步操作API:
void dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
void dispatch_async_f(dispatch_queue_t queue, void *context, dispatch_function_t work);
两个方法都是将任务提交到queue中，提交之后立即返回，不等待任务的的执行。
提交之后，系统会对queue做retain操作，任务执行完成之后，queue再被release。
两个方法的功能一样，区别在于dispatch_async接受block作为参数，dispatch_async_f接受函数。
使用dispatch_async的时候，block会被copy，在block执行完成之后block再release，由于是系统持有block，所以不用担心循环引用的问题，block里面的self不需要weak。
使用dispatch_async_f的时候，context会作为第一个参数传给work函数。如果work不需要参数，context可以传入NULL。work参数不能传入NULL，否则可能发生无法预料的事儿。
异步是一个比较抽象的概念，简单的说就是将任务加入到队列中之后，立即返回，不需要等待任务的执行。
示例代码:
NSLog(@"this is main queue, i want to throw a task to global queue");
dispatch_queue_t globalQueue = dispatch_queue_create("com.stago.global_queue", DISPATCH_QUEUE_SERIAL);
dispatch_async(globalQueue, ^{
// task
});
NSLog(@"this is main queue, throw task completed");
代码运行方式:
1.先在main queue中执行第一个nslog
2.dispatch_async会将block提交到globalQueue中，提交成功之后立即返回
3.main queue执行第二个nslog
4.等global queue中block前面的任务执行完成之后，block被执行。
dispatch_sync
两个同步操作API:
void dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);
void dispatch_sync_f(dispatch_queue_t queue, void *context, dispatch_function_t work);
两个方法都是将任务提交到queue中，任务加入queue之后不会立即返回，等待任务执行完成之后再返回。
dispatch_sync与dispatch_sync_f唯一的区别在于dispatch_sync接收block作为参数，block被系统持有，不需要对self使用weak。dispatch_sync_f接受函数work作为参数，context作为传给work函数的第一个参数。同样，work参数也不能传入NULL，否则会发生无法预料的事儿。
同步表示任务加入到队列中之后不会立即返回，等待任务完成再返回。
示例代码:
NSLog(@"this is main queue, i want to throw a task to global queue");
dispatch_queue_t globalQueue = dispatch_queue_create("com.stago.global_queue", DISPATCH_QUEUE_SERIAL);
dispatch_sync(globalQueue, ^{
// task
});
NSLog(@"this is main queue, throw task completed");
代码的运行方式：
先在main queue中执行第一个nslog
dispatch_sync会将block提交到global queue中，等待block的执行
global queue中block前面的任务执行完成之后，block执行
block执行完成之后，dispatch_sync返回
dispatch_sync之后的代码执行
dispatch_sync的代码执行如图所示
dispatch_sync需要等待block执行完成，同时由于队列串行，block的执行需要等待前面的任务，也就是dispatch_sync执行完成。两者互相等待，永远也不会执行完成，死锁就这样发生了
从这里看发生死锁需要2个条件：
代码运行的当前队列是串行队列
使用sync将任务加入到自己队列中
如果queue是并行队列，或者将任务加入到其他队列中，这是不会发生死锁的。
下面分别分析不同组合情况:
异步执行 + 并行队列
示例代码:
//异步执行 + 并行队列
- (void)asyncConcurrent{
//创建一个并行队列
dispatch_queue_t queue = dispatch_queue_create("标识符", DISPATCH_QUEUE_CONCURRENT);
NSLog(@"---start---");
//使用异步函数封装三个任务
dispatch_async(queue, ^{
NSLog(@"任务1---%@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"任务2---%@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"任务3---%@", [NSThread currentThread]);
});
NSLog(@"---end---");
}
打印结果：
---start---
---end---
任务3---{number = 5, name = (null)}
任务2---{number = 4, name = (null)}
任务1---{number = 3, name = (null)}
思路解析:
--异步执行意味着:
可以开启新的线程
任务可以先绕过不执行，回头再来执行--并行队列意味着:
任务之间不需要排队，且具有同时被执行的“权利”--两者组合后的结果:
开了三个新线程
函数在执行时，先打印了start和end，再回头执行这三个任务
这三个任务是同时执行的，没有先后，所以打印结果是“任务3-->任务2-->任务1”
运行流程:
异步执行 + 串行队列
示例代码:
//异步执行 + 串行队列
- (void)asyncSerial{
//创建一个串行队列
dispatch_queue_t queue = dispatch_queue_create("标识符", DISPATCH_QUEUE_SERIAL);
NSLog(@"---start---");
//使用异步函数封装三个任务
dispatch_async(queue, ^{
NSLog(@"任务1---%@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"任务2---%@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"任务3---%@", [NSThread currentThread]);
});
NSLog(@"---end---");
}
打印结果:
---start---
---end---
任务1---{number = 3, name = (null)}
任务2---{number = 3, name = (null)}
任务3---{number = 3, name = (null)}
思路解析:
--异步执行意味着:
可以开启新的线程
任务可以先绕过不执行，回头再来执行--串行队列意味着:
任务必须按添加进队列的顺序挨个执行--两者组合后的结果:
开了一个新的子线程
函数在执行时，先打印了start和end，再回头执行这三个任务
这三个任务是按顺序执行的，所以打印结果是“任务1-->任务2-->任务3”
运行流程:
同步执行 + 并行队列
示例代码:
//同步执行 + 并行队列
- (void)syncConcurrent{
//创建一个并行队列
dispatch_queue_t queue = dispatch_queue_create("标识符", DISPATCH_QUEUE_CONCURRENT);
NSLog(@"---start---");
//使用同步函数封装三个任务
dispatch_sync(queue, ^{
NSLog(@"任务1---%@", [NSThread currentThread]);
});
dispatch_sync(queue, ^{
NSLog(@"任务2---%@", [NSThread currentThread]);
});
dispatch_sync(queue, ^{
NSLog(@"任务3---%@", [NSThread currentThread]);
});
NSLog(@"---end---");
}
打印结果：
---start---
任务1---{number = 1, name = main}
任务2---{number = 1, name = main}
任务3---{number = 1, name = main}
---end---
思路解析:
--同步执行执行意味着:
不能开启新的线程
任务创建后必须执行完才能往下走--并行队列意味着
任务必须按添加进队列的顺序挨个执行--两者组合后的结果:
所有任务都只能在主线程中执行
函数在执行时，必须按照代码的书写顺序一行一行地执行完才能继续
运行流程:
同步执行+ 串行队列
示例代码:
- (void)syncSerial{
//创建一个串行队列
dispatch_queue_t queue = dispatch_queue_create("标识符", DISPATCH_QUEUE_SERIAL);
NSLog(@"---start---");
//使用异步函数封装三个任务
dispatch_sync(queue, ^{
NSLog(@"任务1---%@", [NSThread currentThread]);
});
dispatch_sync(queue, ^{
NSLog(@"任务2---%@", [NSThread currentThread]);
});
dispatch_sync(queue, ^{
NSLog(@"任务3---%@", [NSThread currentThread]);
});
NSLog(@"---end---");
}
打印结果:
---start---
任务1---{number = 1, name = main}
任务2---{number = 1, name = main}
任务3---{number = 1, name = main}
---end---
思路解析:
这里的执行原理和步骤图跟“同步执行+并发队列”是一样的，只要是同步执行就没法开启新的线程，所以多个任务之间也一样只能按顺序来执行，
异步执行+主队列
示例代码
- (void)asyncMain{
//获取主队列
dispatch_queue_t queue = dispatch_get_main_queue();
NSLog(@"---start---");
//使用异步函数封装三个任务
dispatch_async(queue, ^{
NSLog(@"任务1---%@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"任务2---%@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"任务3---%@", [NSThread currentThread]);
});
NSLog(@"---end---");
}
打印结果：
---start---
---end---
任务1---{number = 1, name = main}
任务2---{number = 1, name = main}
任务3---{number = 1, name = main}
思路解析:
--异步执行意味着:
可以开启新的线程
任务可以先绕过不执行，回头再来执行--主队列跟串行队列的区别:
队列中的任务一样要按顺序执行
主队列中的任务必须在主线程中执行，不允许在子线程中执行--以上条件组合后得出结果：
所有任务都可以先跳过，之后再来“按顺序”执行
运行流程:
同步执行+主队列（死锁）
示例代码:
- (void)syncMain{
//获取主队列
dispatch_queue_t queue = dispatch_get_main_queue();
NSLog(@"---start---");
//使用同步函数封装三个任务
dispatch_sync(queue, ^{
NSLog(@"任务1---%@", [NSThread currentThread]);
});
dispatch_sync(queue, ^{
NSLog(@"任务2---%@", [NSThread currentThread]);
});
dispatch_sync(queue, ^{
NSLog(@"任务3---%@", [NSThread currentThread]);
});
NSLog(@"---end---");
}
打印结果:
---start---
思路解析:
--主队列中的任务必须按顺序挨个执行
--任务1要等主线程有空的时候（即主队列中的所有任务执行完）才能执行
--主线程要执行完“打印end”的任务后才有空
--“任务1”和“打印end”两个任务互相等待，造成死锁
运行流程: