一.GCD的简介
Grand Central Dispatch(GCD)是 Apple 开发的一个多核编程的较新的解决方法。它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。它是一个在线程池模式的基础上执行的并发任务。在 Mac OS X 10.6 雪豹中首次推出，也可在 iOS 4 及以上版本使用。
在GCD中有两种队列：串行队列和并发队列。两者都符合FIFO（先进先出）的原则，两者的主要区别是：执行顺序不同，以及开启线程数不同。
串行队列（Serial Dispaych Queue）:
每次只有一个任务被执行。让任务一个接着一个地执行。（只开启一个线程，一个任务执行完毕后，在执行下一个任务）
并发队列（ConCurrent Dispatch Queue）
可以让多个任务并发（同时）执行。（可以开启多个线程，并且同时执行任务）
注意：并发队列的并发功能只有在异步（dispatch_async）函数下才有效
三、GCD 的使用步骤
1.创建一个队列（串行队列或并发队列）
2.将任务追加到任务的等待队列中，然后系统就会根据任务类型执行任务（同步执行或异步执行）
队列的创建方法/获取方法
可以使用dispatch_queue_create来创建队列，需要传入两个参数，第一个参数表示队列的唯一标识符，用于debug，可为空，Dispatch Queue的名称推荐使用应用程序ID这种逆序全程域名；第二个参数用来识别是串行队列还是并发队列。DISPATCH_QUEUE_SERIAL 表示串行队列，DISPATCH_QUEUE_CONCURRENT表示并发队列。
// 串行队列的创建方法
dispatch_queue_t queue = dispatch_queue_create("net.nange.test", DISPATCH_QUEUE_SERIAL);
// 并发队列的创建方法
dispatch_queue_t queue1 = dispatch_queue_create("net.nange.test", DISPATCH_QUEUE_CONCURRENT)
对于串行队列，GCD提供了一种特殊的串行队列：主队列（Main Dispatch QUeue）
所有放在主队列中的任务，都会放到主线程中执行
可使用dispatch_get_main_queue()获得主队列
// 主队列的获取方法
dispatch_queue_t queue = dispatch_get_main_queue();
对于并发队列，GCD默认提供了全局并发队列（Global Dispatch Queue）
可以使用dispatch_get_global_queue来获取。需要传入两个参数。第一个参数表示队列的优先级，一般用DISPATCH_QUEUE_PRIORITY_DEFAULT。第二个参数暂时没用，用0即可。
//全局并发队列的获取方法
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
任务的创建方法
GCD提供了同步执行任务的创建方法dispatch_sync和异步执行任务创建方法dispatch_async.
// 同步执行任务创建方法
dispatch_sync(queue, ^{
// 这里放同步执行任务代码
});
// 异步执行任务创建方法
dispatch_async(queue, ^{
// 这里放异步执行任务代码
});
虽然使用GCD只需两步，但是既然我们有两种队列（串行队列/并发队列），两种任务执行方式（同步执行/异步执行），那么我们就有了四种不同的组合方式。这四种不同的组合方式是：
1.同步执行 + 并发队列
2.异步执行 + 并发队列
3.同步执行 + 串行队列
4.异步执行 + 串行队列
实际上，刚才还说了两种特殊的队列：全局并发队列、主队列。全局并发队列可以作为普通并发队列来使用。但是主队列因为有点特殊，所以我们就又多了两种组合方式。这样就有六种不同的组合方式了。
5.同步执行 + 主队列
6.异步执行 + 主队列
那么这几种不同的组合方式各有什么区别呢，直接看结果 再做讲解
四.GCD的基本使用
先来讲讲并发队列的两种执行方式
4.1 同步执行 + 并发队列
在当前线程中执行任务，不会开启新线程，执行完一个任务，在执行下一个任务
/*
同步执行 + 并发队列
特点：在当前线程中执行任务，不会开启新线程，执行完一个任务，在执行下一个任务
*/
-(void)syncConcurrent{
NSLog(@"currentThread---%@",[NSThread currentThread]);
NSLog(@"syncConcurrent--begin");
dispatch_queue_t queue = dispatch_queue_create("net.nange.QQ", DISPATCH_QUEUE_CONCURRENT);
dispatch_sync(queue, ^{
// 追加任务1
for (int i=0; i<2; ++i) {
[NSThread sleepForTimeInterval:2]; //模拟耗时操作
NSLog(@"1----%@",[NSThread currentThread]); //打印当前线程
}
});
dispatch_sync(queue, ^{
// 追加任务2
for (int i=0; i<2; ++i) {
[NSThread sleepForTimeInterval:2];//模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]);//打印当前线程
}
});
dispatch_sync(queue, ^{
// 追加任务3
for (int i=0 ; i<2; i++) {
[NSThread sleepForTimeInterval:2];//模拟耗时操作
NSLog(@"3---%@",[NSThread currentThread]);//打印当前线程
}
});
NSLog(@"syncCurrent-----end");
}
4.2 异步执行 + 并发队列
可以开启多个线程，任务交替（同时执行）
/*
异步执行 + 并发队列
特点：可以开启多个线程，任务交替（同时执行）
*/
-(void)asyncConcurrent{
NSLog(@"currentThread---%@",[NSThread currentThread]);
NSLog(@"asyncConcurrent--begin");
dispatch_queue_t queue = dispatch_queue_create("net.nange.QQ", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
// 追加任务1
for (int i=0; i<2; ++i) {
[NSThread sleepForTimeInterval:2]; //模拟耗时操作
NSLog(@"1----%@",[NSThread currentThread]); //打印当前线程
}
});
dispatch_async(queue, ^{
// 追加任务2
for (int i=0; i<2; ++i) {
[NSThread sleepForTimeInterval:2];//模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]);//打印当前线程
}
});
dispatch_async(queue, ^{
// 追加任务3
for (int i=0 ; i<2; i++) {
[NSThread sleepForTimeInterval:2];//模拟耗时操作
NSLog(@"3---%@",[NSThread currentThread]);//打印当前线程
}
});
NSLog(@"syncCurrent-----end");
}
4.3 同步执行 + 串行队列
不会开启新线程，在当前线程执行任务。任务是串行的，执行完一个任务，在执行下一个任务
/*
同步执行 + 串行队列
特点：不回开启新线程，在当前线程执行任务中。任务是串行的，在执行完一个任务，在执行下一个任务
*/
-(void)syncSerial{
NSLog(@"currentThread---%@",[NSThread currentThread]);
NSLog(@"syncSerial--begin");
dispatch_queue_t queue = dispatch_queue_create("net.nange.QQ", DISPATCH_QUEUE_SERIAL);
dispatch_sync(queue, ^{
// 追加任务1
for (int i=0; i<2; ++i) {
[NSThread sleepForTimeInterval:2]; //模拟耗时操作
NSLog(@"1----%@",[NSThread currentThread]); //打印当前线程
}
});
dispatch_sync(queue, ^{
// 追加任务2
for (int i=0; i<2; ++i) {
[NSThread sleepForTimeInterval:2];//模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]);//打印当前线程
}
});
dispatch_sync(queue, ^{
// 追加任务3
for (int i=0 ; i<2; i++) {
[NSThread sleepForTimeInterval:2];//模拟耗时操作
NSLog(@"3---%@",[NSThread currentThread]);//打印当前线程
}
});
NSLog(@"syncCurrent-----end");
}
4.4 异步执行 + 串行队列
会开启新线程，但是因为任务是串行的，执行完一个任务，在执行下一个任务
/*
异步执行 + 串行队列
特点：会开启新线程，但是因为任务是串行的，执行完一个任务，在执行下一个任务
*/
-(void)asyncSerial{
NSLog(@"currentThread---%@",[NSThread currentThread]);
NSLog(@"asyncSerial--begin");
dispatch_queue_t queue = dispatch_queue_create("net.nange.QQ", DISPATCH_QUEUE_SERIAL);
dispatch_async(queue, ^{
// 追加任务1
for (int i=0; i<2; ++i) {
[NSThread sleepForTimeInterval:2]; //模拟耗时操作
NSLog(@"1----%@",[NSThread currentThread]); //打印当前线程
}
});
dispatch_async(queue, ^{
// 追加任务2
for (int i=0; i<2; ++i) {
[NSThread sleepForTimeInterval:2];//模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]);//打印当前线程
}
});
dispatch_async(queue, ^{
// 追加任务3
for (int i=0 ; i<2; i++) {
[NSThread sleepForTimeInterval:2];//模拟耗时操作
NSLog(@"3---%@",[NSThread currentThread]);//打印当前线程
}
});
NSLog(@"syncCurrent-----end");
}
主队列：GCD自带的一种特殊的串行队列
所有放在主队列中的任务，都会放到主线程中执行
可使用disPatch_get_main_queue()获得主队列
4.5 同步执行 + 主队列
同步执行 + 主队列 在不用线程中调用结果也是不一样，在主线程中调用会出现死锁，而在其他线程中 则不会。
4.5.1 在主线程中调用 （同步执行 + 主队列）
互相等待卡住不可行
/*
同步执行 + 主队列
特点（主线程调用）：互等卡住不执行
特点（其他线程调用）：不会开启新线程，执行完一个任务，再执行下一个任务。
*/
-(void)syncMain{
NSLog(@"currentThread---%@",[NSThread currentThread]);
NSLog(@"asyncSerial--begin");
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_sync(queue, ^{
// 追加任务1
for (int i=0; i<2; ++i) {
[NSThread sleepForTimeInterval:2]; //模拟耗时操作
NSLog(@"1----%@",[NSThread currentThread]); //打印当前线程
}
});
dispatch_sync(queue, ^{
// 追加任务2
for (int i=0; i<2; ++i) {
[NSThread sleepForTimeInterval:2];//模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]);//打印当前线程
}
});
dispatch_sync(queue, ^{
// 追加任务3
for (int i=0 ; i<2; i++) {
[NSThread sleepForTimeInterval:2];//模拟耗时操作
NSLog(@"3---%@",[NSThread currentThread]);//打印当前线程
}
});
NSLog(@"syncCurrent-----end");
}
4.5.2 在其他线程中调用
不会开启新线程，执行完一个任务，在执行下一个任务
使用NSThread 的detachNewthreadSelect 方法会创建线程，并自动启动线程执行
selector 任务
[NSThread detachNewThreadSelector:@selector(syncMain) toTarget:self withObject:nil];
4.6 异步执行 + 主队列
只有在主线程中执行任务，执行完一个任务，在执行下一个任务
/*
异步执行 + 主队列
特点：只在主线程中执行任务，执行完一个任务，在执行下一个任务
*/
-(void)asyncMain{
NSLog(@"currentThread---%@",[NSThread currentThread]);
NSLog(@"asyncSerial--begin");
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_async(queue, ^{
// 追加任务1
for (int i=0; i<2; ++i) {
[NSThread sleepForTimeInterval:2]; //模拟耗时操作
NSLog(@"1----%@",[NSThread currentThread]); //打印当前线程
}
});
dispatch_async(queue, ^{
// 追加任务2
for (int i=0; i<2; ++i) {
[NSThread sleepForTimeInterval:2];//模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]);//打印当前线程
}
});
dispatch_async(queue, ^{
// 追加任务3
for (int i=0 ; i<2; i++) {
[NSThread sleepForTimeInterval:2];//模拟耗时操作
NSLog(@"3---%@",[NSThread currentThread]);//打印当前线程
}
});
NSLog(@"syncCurrent-----end");
}
5.GCD线程间的通信
iOS中 我们一般在主线程里边进行UI刷新，例如：点击、滚动、拖拽等事件。我们通常把一些耗时的操作放在其他线程，比如说图片下载、文件上传等耗时操作。而我们有时候在其他线程完成了耗时操作，需要回到主线程，那么就用到了线程之间的通讯。
-(void)asyncMain{
// 获取全局并发队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// 获取主队列
dispatch_queue_t mainQueue = dispatch_get_main_queue();
dispatch_async(queue, ^{
// 异步 追加任务
for (int i=0; i<2; ++i) {
[NSThread sleepForTimeInterval:2]; //模拟耗时操作
NSLog(@"1----%@",[NSThread currentThread]); //打印当前线程
}
// 回到主线程
dispatch_async(mainQueue, ^{
// 追加在主线程中执行的任务
[NSThread sleepForTimeInterval:2];//模拟耗时操作
NSLog(@"2-----%@",[NSThread currentThread]);//打印当前线程
});
});
}
6.GCD的其他方法
6.1 GCD栅栏方法：dispatch_barrier_async
/*
栅栏方法
*/
-(void)barrier{
dispatch_queue_t queue = dispatch_queue_create("net.nange.test", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
// 异步 追加任务1
for (int i=0; i<2; ++i) {
[NSThread sleepForTimeInterval:2]; //模拟耗时操作
NSLog(@"1----%@",[NSThread currentThread]); //打印当前线程
}
});
dispatch_async(queue, ^{
// 异步 追加任务2
for (int i=0; i<2; ++i) {
[NSThread sleepForTimeInterval:2]; //模拟耗时操作
NSLog(@"2----%@",[NSThread currentThread]); //打印当前线程
}
});
dispatch_barrier_async(queue, ^{
// 追加任务barrier
for(int i=0;i<2;i++){
[NSThread sleepForTimeInterval:2];
NSLog(@"barrier-----%@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
// 异步 追加任务3
for (int i=0; i<2; ++i) {
[NSThread sleepForTimeInterval:2]; //模拟耗时操作
NSLog(@"3----%@",[NSThread currentThread]); //打印当前线程
}
});
dispatch_async(queue, ^{
// 异步 追加任务4
for (int i=0; i<2; ++i) {
[NSThread sleepForTimeInterval:2]; //模拟耗时操作
NSLog(@"4----%@",[NSThread currentThread]); //打印当前线程
}
});
}
6.2 GCD延时执行方法：dispatch_after
指定时间（5秒）之后执行某个任务。可以用GCD的dispatch_after函数实现。
需要注意的是：dispatch_after函数并不是在指定时间之后才开始处理，而是在指定时间之后将任务追加到队列中。严格来说，这个时间并不是绝对准确的，但想要大致延迟执行任务，dispatch_after函数是很有效的。
/*
延时执行方法 diapatch_after
*/
-(void)after{
NSLog(@"currerntThread---%@",[NSThread currentThread]);//打印当前线程
NSLog(@"asyncMain--begin");
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0*NSEC_PER_SEC)),dispatch_get_main_queue(), ^{
// 2.0秒后异步追加任务代码到主队列，并开始执行
NSLog(@"after----%@",[NSThread currentThread]);//打印当前线程
});
}
6.3 GCD 一次性代码（只执行一次）：dispatch_once
我们在创建单例、或者有整个程序运行过程中只执行一次的代码时，我们就用到了GCD的dispatch_once函数。使用dispatch_once函数能保证某段代码在程序运行过程中只被执行一次，并且即使在多线程的环境下，dispatch_once也可以保证线程的安全。
/*
一次性代码（只执行一次）dispatch_once
*/
-(void)once{
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
//只执行一次的代码（这里面默认是线程安全的）
});
}
6.4 GCD快速迭代方法：dispatch_apply
通常我们会用for循环，但是GCD给我们提供了快速迭代的函数dispatch_apply.dispatch_apply按照指定的次数将指定的任务追加到指定的队列中，并等待全部队列执行结束。
/*
快速迭代方法 dispatch_apply
*/
-(void)apply{
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
NSLog(@"apply----begin");
dispatch_apply(6, queue, ^(size_t index) {
NSLog(@"%zd-----%@",index,[NSThread currentThread]);
});
NSLog(@"apply----end");
}
6.5 GCD队列组：dispatch_group
需求：分别异步执行2个耗时任务，然后当2个耗时任务都执行完毕后再回到主线程执行任务。这时候我们可以使用到GCD的队列组
6.5.1 dispatch_group_notify
监听group中任务的完成状态，当所有的任务都快执行完成后，追加任务到group中，并执行任务
/*
队列组 dispatch_group_notify
*/
-(void)groupNotify{
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"group---begin");
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 追加任务1
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
}
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 追加任务2
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
}
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
// 等前面的异步任务1、任务2都执行完毕后，回到主线程执行下边任务
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程
}
NSLog(@"group---end");
});
}
6.5.2 dispat_group_wait
暂停当前线程（阻塞当前线程），等待指定的group中的任务执行完成后，才会往下继续执行
/**
* 队列组 dispatch_group_wait
*/
- (void)groupWait {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"group---begin");
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 追加任务1
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
}
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 追加任务2
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
}
});
// 等待上面的任务全部完成后，会往下继续执行（会阻塞当前线程）
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
NSLog(@"group---end");
}
6.5.3 dispatch_group_enter、dispatch_group_leave
dispatch_group_enter标志着一个任务追加到 group，执行一次，相当于 group 中未执行完毕任务数+1
dispatch_group_leave标志着一个任务离开了 group，执行一次，相当于 group 中未执行完毕任务数-1。
当 group 中未执行完毕任务数为0的时候，才会使dispatch_group_wait解除阻塞，以及执行追加到dispatch_group_notify中的任务。
/**
* 队列组 dispatch_group_enter、dispatch_group_leave
*/
- (void)groupEnterAndLeave
{
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"group---begin");
dispatch_group_t group = dispatch_group_create();
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_enter(group);
dispatch_async(queue, ^{
// 追加任务1
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
}
dispatch_group_leave(group);
});
dispatch_group_enter(group);
dispatch_async(queue, ^{
// 追加任务2
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
}
dispatch_group_leave(group);
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
// 等前面的异步操作都执行完毕后，回到主线程.
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程
}
NSLog(@"group---end");
});
// // 等待上面的任务全部完成后，会往下继续执行（会阻塞当前线程）
// dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
//
// NSLog(@"group---end");
}
6.6 GCD信号量 :dispatch_semaphoreDispatch Semaphore提供了三个函数。
dispatch_semaphore_create：创建一个Semaphore并初始化信号的总量
dispatch_semaphore_signal：发送一个信号，让信号总量加1
dispatch_semaphore_wait：可以使总信号量减1，当信号总量为0时就会一直等待（阻塞所在线程），否则就可以正常执行。
注意：信号量的使用前提是：想清楚你需要处理哪个线程等待（阻塞），又要哪个线程继续执行，然后使用信号量。
Dispatch Semaphore 在实际开发中主要用于：
- 保持线程同步，将异步执行任务转换为同步执行任务
- 保证线程安全，为线程加锁
- (NSArray *)tasksForKeyPath:(NSString *)keyPath {
__block NSArray *tasks = nil;
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
[self.session getTasksWithCompletionHandler:^(NSArray *dataTasks, NSArray *uploadTasks, NSArray *downloadTasks) {
if ([keyPath isEqualToString:NSStringFromSelector(@selector(dataTasks))]) {
tasks = dataTasks;
} else if ([keyPath isEqualToString:NSStringFromSelector(@selector(uploadTasks))]) {
tasks = uploadTasks;
} else if ([keyPath isEqualToString:NSStringFromSelector(@selector(downloadTasks))]) {
tasks = downloadTasks;
} else if ([keyPath isEqualToString:NSStringFromSelector(@selector(tasks))]) {
tasks = [@[dataTasks, uploadTasks, downloadTasks] valueForKeyPath:@"@unionOfArrays.self"];
}
dispatch_semaphore_signal(semaphore);
}];
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
return tasks;
}
接下来，我们利用Dispatch Semaphore实现线程同步，将异步执行任务转换为同步执行任务。
/**
* semaphore 线程同步
*/
- (void)semaphoreSync {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"semaphore---begin");
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
__block int number = 0;
dispatch_async(queue, ^{
// 追加任务1
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
number = 100;
dispatch_semaphore_signal(semaphore);
});
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
NSLog(@"semaphore---end,number = %d",number);
}
6.6.2 Dispatch Semaphore线程安全和线程同步（为线程加锁）
线程安全：如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行结果一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的
若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作（更改变量），一般都需要考虑线程同步，否则的话就可能影响线程安全。
线程同步：可理解为线程 A 和 线程 B 一块配合，A 执行到一定程度时要依靠线程 B 的某个结果，于是停下来，示意 B 运行；B 依言执行，再将结果给 A；A 再继续操作。
举个简单例子就是：两个人在一起聊天。两个人不能同时说话，避免听不清(操作冲突)。等一个人说完(一个线程结束操作)，另一个再说(另一个线程再开始操作)。
下面，我们模拟火车票售卖的方式，实现 NSThread 线程安全和解决线程同步问题。
场景：总共有50张火车票，有两个售卖火车票的窗口，一个是北京火车票售卖窗口，另一个是上海火车票售卖窗口。两个窗口同时售卖火车票，卖完为止。
/**
* 非线程安全：不使用 semaphore
* 初始化火车票数量、卖票窗口(非线程安全)、并开始卖票
*/
- (void)initTicketStatusNotSave {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"semaphore---begin");
self.ticketSurplusCount = 50;
// queue1 代表北京火车票售卖窗口
dispatch_queue_t queue1 = dispatch_queue_create("net.bujige.testQueue1", DISPATCH_QUEUE_SERIAL);
// queue2 代表上海火车票售卖窗口
dispatch_queue_t queue2 = dispatch_queue_create("net.bujige.testQueue2", DISPATCH_QUEUE_SERIAL);
__weak typeof(self) weakSelf = self;
dispatch_async(queue1, ^{
[weakSelf saleTicketNotSafe];
});
dispatch_async(queue2, ^{
[weakSelf saleTicketNotSafe];
});
}
/**
* 售卖火车票(非线程安全)
*/
- (void)saleTicketNotSafe {
while (1) {
if (self.ticketSurplusCount > 0) { //如果还有票，继续售卖
self.ticketSurplusCount--;
NSLog(@"%@", [NSString stringWithFormat:@"剩余票数：%d 窗口：%@", self.ticketSurplusCount, [NSThread currentThread]]);
[NSThread sleepForTimeInterval:0.2];
} else { //如果已卖完，关闭售票窗口
NSLog(@"所有火车票均已售完");
break;
}
}
}
可以看到在不考虑线程安全，不使用 semaphore 的情况下，得到票数是错乱的，这样显然不符合我们的需求，所以我们需要考虑线程安全问题。
6.6.2.2 线程安全（使用semaphore加锁）
考虑线程安全的代码
/**
* 线程安全：使用 semaphore加锁
* 初始化火车票数量、卖票窗口(线程安全)、并开始卖票
*/
- (void)initTicketStatusNotSave {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"semaphore---begin");
semaphoreLock = dispatch_semaphore_create(1);
self.ticketSurplusCount = 50;
// queue1 代表北京火车票售卖窗口
dispatch_queue_t queue1 = dispatch_queue_create("net.bujige.testQueue1", DISPATCH_QUEUE_SERIAL);
// queue2 代表上海火车票售卖窗口
dispatch_queue_t queue2 = dispatch_queue_create("net.bujige.testQueue2", DISPATCH_QUEUE_SERIAL);
__weak typeof(self) weakSelf = self;
dispatch_async(queue1, ^{
[weakSelf saleTicketNotSafe];
});
dispatch_async(queue2, ^{
[weakSelf saleTicketNotSafe];
});
}
/**
* 售卖火车票(非线程安全)
*/
- (void)saleTicketNotSafe {
while (1) {
// 相当于加锁
dispatch_semaphore_wait(semaphoreLock, DISPATCH_TIME_FOREVER);
if (self.ticketSurplusCount > 0) { //如果还有票，继续售卖
self.ticketSurplusCount--;
NSLog(@"%@", [NSString stringWithFormat:@"剩余票数：%d 窗口：%@", self.ticketSurplusCount, [NSThread currentThread]]);
[NSThread sleepForTimeInterval:0.2];
} else { //如果已卖完，关闭售票窗口
NSLog(@"所有火车票均已售完");
// 相当于解锁
dispatch_semaphore_signal(semaphoreLock);
break;
}
// 相当于解锁
dispatch_semaphore_signal(semaphoreLock);
}
}