iOS多线程-GCD

简介

• GCD(Grand Central Dispatch),大型中枢调度技术,纯C语言，提供了非常多强大的函数,是Apple开发的一个多核编程的较新的解决方法。它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。它是一个在线程池模式的基础上执行的并行任务。在Mac OS X 10.6雪豹中首次推出，也可在IOS 4及以上版本使用。
• GCD是苹果公司为多核的并行运算提出的解决方案.
• GCD会自动利用更多的CPU内核.
• GCD会自动管理线程的生命周期（创建线程、调度任务、销毁线程).
• 程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码.

任务和队列

• 任务 : 执行什么操作
• 队列 : 用了存放任务
• GCD的使用就2个步骤:
  
  1. 定制任务 : 确定想做的事情
  2. 将任务添加到队列中 : GCD会自动将队列中的任务取出，放到对应的线程中执行,任务的取出遵循队列的FIFO原则：先进先出，后进后出

任务

GCD中有2个用来执行任务的常用函数

• 同步函数 : 用同步的方式执行任务

  • 同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等待，直到队列里面的任务(block里面的代码)完成之后再继续执行。
  • 只能在当前线程中执行任务，不具备开启新线程的能力。

  • 异步函数 : 用异步的方式执行任务
    

  • 异步添加任务到指定的队列中，它不会做任何等待，可以继续执行任务。
    
  • 可以在新的线程中执行任务，具备开启新线程的能力。
    
  • 注意:异步执行（async）虽然具有开启新线程的能力，但是并不一定开启新线程。这跟任务所指定的队列类型有关（下面会讲）。

队列（Dispatch Queue）

• 指执行任务的等待队列，即用来存放任务的队列。队列是一种特殊的线性表，采用 FIFO（先进先出）的原则，即新任务总是被插入到队列的末尾，而读取任务的时候总是从队列的头部开始读取。每读取一个任务，则从队列中释放一个任务。队列的结构可参考下图：
  

• GCD的队列可以分为2大类型:串行队列和并发队列。两者都符合 FIFO（先进先出）的原则。两者的主要区别是：执行顺序不同，以及开启线程数不同。

串行队列（Serial Dispatch Queue）

让任务一个接着一个地执行（只开启一个线程，一个任务执行完毕后，再执行下一个任务）

并发队列（Concurrent Dispatch Queue）

可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）
并发功能只有在异步（dispatch_async）函数下才有效

GCD 的使用步骤

GCD 的使用步骤其实很简单，只有三步。
1. 创建一个队列（串行队列或并发队列）
2. 将任务追加到任务的等待队列中,然后根据任务类型执行任务（同步执行或异步执行）

• 队列创建

dispatch_queue_t dispatch_queue_create(const char *_Nullable label,dispatch_queue_attr_t _Nullable attr);
参数:
const char *_Nullable label 队列名称
dispatch_queue_attr_t _Nullable attr 队列类型

// 串行队列的创建方法,队列类型传递NULL或者DISPATCH_QUEUE_SERI
dispatch_queue_t queue = dispatch_queue_create("serialDispatchQueue", DISPATCH_QUEUE_SERIAL);
// 并发队列的创建方法,队列类型传递DISPATCH_QUEUE_CONCURRENT
dispatch_queue_t queue = dispatch_queue_create("concurrentDispatchQueue", DISPATCH_QUEUE_CONCURRENT);

主队列是GCD自带的一种特殊的串行队列,放在主队列中的任务，都会放到主线程中执行

dispatch_queue_t dispatch_get_main_queue(void)
{
    return DISPATCH_GLOBAL_OBJECT(dispatch_queue_t, _dispatch_main_q);
}

GCD默认已经提供了全局的并发队列，供整个应用使用，可以无需手动创建

dispatch_queue_t dispatch_get_global_queue(long identifier, unsigned long flags);

参数1:long identifier//优先级
ios 8.0 告诉队列执行任务的“服务质量 quality of service”，系统提供的参数有：
     QOS_CLASS_USER_INTERACTIVE 0x21,  用户交互(希望尽快完成，不要放太耗时操作)
     QOS_CLASS_USER_INITIATED 0x19,    用户期望(不要放太耗时操作)
     QOS_CLASS_DEFAULT 0x15,           默认(不是给程序员使用的，用来重置对列使用的)
     QOS_CLASS_UTILITY 0x11,           实用工具(耗时操作，可以使用这个选项)
     QOS_CLASS_BACKGROUND 0x09,        后台
     QOS_CLASS_UNSPECIFIED 0x00,       未指定
  iOS 7.0 之前 优先级
     DISPATCH_QUEUE_PRIORITY_HIGH 2                 高优先级
     DISPATCH_QUEUE_PRIORITY_DEFAULT 0              默认优先级
     DISPATCH_QUEUE_PRIORITY_LOW (-2)               低优先级
     DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN  后台优先级        
参数2:unsigned long flags
苹果官方文档是这样解释的： Flags that are reserved for future use。标记是为了未来使用保留的！所以这个参数应该永远指定为0
   如果做ios8.0与ios7.0的适配，可以这样创建全局队列：
   dispatch_queue_t q = dispatch_get_global_queue(0, 0);

• 任务的创建函数
  GCD 提供了同步执行任务的创建方法dispatch_sync和异步执行任务创建方法dispatch_async。

// 同步函数执行同步任务
void dispatch_sync(dispatch_queue_t queue, DISPATCH_NOESCAPE dispatch_block_t block);
// 异步函数执行异步任务
void dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
参数:
queue : 队列
block : 任务(block里面放同步或者异步执行任务的代码)

术语

同步、异步、并发、串行

同步和异步主要影响：能不能开启新的线程
同步：只在当前线程中执行任务，不具备开启新线程的能力
异步：可以在新的线程中执行任务，具备开启新线程的能力
并发和串行主要影响：任务的执行方式
并发：允许多个任务并发（同时）执行
串行：一个任务执行完毕后，再执行下一个任务

各种队列的执行效果

任务函数	并发队列	创建的串行队列	主队列
同步(sync)	没有开启新线程,串行执行任务	没有开启新线程,串行执行任务	主线程调用：死锁卡住不执行,其他线程调用没有开启新线程，串行执行任务
异步 (async)	开启新线程,并发执行任务	有开启新线程,串行执行任务	没有开启新线程,串行执行任务

注意:使用sync函数往当前串行队列中添加任务，会阻塞当前的串行队列.

示例:

• 1.同步函数+并发队列
  特点:不开启新的线程,当前线程中执行,任务一个个执行,不能同时并发执行.

// 同步函数+并发队列
- (void)syncAndConcurrent{
    NSLog(@"开始:%@",[NSThread currentThread]);
    //创建并发队列
    dispatch_queue_t queue = dispatch_queue_create("conturret", DISPATCH_QUEUE_CONCURRENT);
    //同步函数执行同步任务
    dispatch_sync(queue, ^{
        for (int i = 0; i<3; i++) {
            [NSThread sleepForTimeInterval:2];//暂停2秒,模拟耗时操作
            NSLog(@"任务1:%@",[NSThread currentThread]);
        }

    });
    //同步函数执行同步任务
    dispatch_sync(queue, ^{
        for (int i = 0; i<3; i++) {
            [NSThread sleepForTimeInterval:2];//暂停2秒,模拟耗时操作
            NSLog(@"任务2:%@",[NSThread currentThread]);
        }
    });
    //同步函数执行同步任务
    dispatch_sync(queue, ^{
        for (int i = 0; i<3; i++) {
            [NSThread sleepForTimeInterval:2];//暂停2秒,模拟耗时操作
            NSLog(@"任务3:%@",[NSThread currentThread]);
        }
    });
    NSLog(@"结束:%@",[NSThread currentThread]);
}

由结果可见并没有开启线程(同步函数不具备开启线程的能力,并且block里面代码执行完了才会返回当前函数往下执行),虽是并发队列也是一个个按顺序执行任务,所以同步函数并发队列并不会并发执行任务,还是串行执行的任务,所以一般这样用是没有意义的

• 2.同步函数+串行队列

// 同步函数+串行队列
- (void)syncSerial{
    NSLog(@"开始:%@",[NSThread currentThread]);
    dispatch_queue_t  queue = dispatch_queue_create("serial", DISPATCH_QUEUE_SERIAL);//创见串行队列
    dispatch_sync(queue, ^{
        NSLog(@"任务1:%@",[NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"任务2:%@",[NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"任务3:%@",[NSThread currentThread]);
    });
    NSLog(@"结束:%@",[NSThread currentThread]);
}

不开启新的线程,任务一个个串行执行(同步函数则得等待block中的代码即任务执行完后才返回来继续往下执行,串行队列任务是一个个按顺序执行的)

• 3.异步函数+并发队列

// 异步函数+并发队列
- (void)asyncConcurrent{
    NSLog(@"开始:%@",[NSThread currentThread]);
    dispatch_queue_t  queue = dispatch_queue_create("serial", DISPATCH_QUEUE_CONCURRENT);//创见并发队列
    //异步函数执行
    dispatch_async(queue, ^{
        for (int i = 0; i<3; i++) {
            [NSThread sleepForTimeInterval:2];//暂停2秒,模拟耗时操作
            NSLog(@"任务1:%@",[NSThread currentThread]);
        }

    });
    //异步函数执行
    dispatch_async(queue, ^{
        for (int i = 0; i<3; i++) {
            [NSThread sleepForTimeInterval:2];//暂停2秒,模拟耗时操作
            NSLog(@"任务2:%@",[NSThread currentThread]);
        }
    });
    //异步函数执行
    dispatch_async(queue, ^{
        for (int i = 0; i<3; i++) {
            [NSThread sleepForTimeInterval:2];//暂停2秒,模拟耗时操作
            NSLog(@"任务3:%@",[NSThread currentThread]);
        }
    });
    NSLog(@"结束:%@",[NSThread currentThread]);
}

结果可见:异步函数+并发队列开启了多条新的线程,并且并发执行(异步函数具备开启新线程的能力,并发队列可开启多个线程，同时执行多个任务.”开始”,和”结束”先执行说明当前线程没有等待直接往下执行，并且直接开启了新线程，在新线程中各任务并发执行任务)

• 4.异步函数+串行队列

// 异步函数+串行队列
- (void)asyncSerail{
    NSLog(@"开始:%@",[NSThread currentThread]);
    dispatch_queue_t  queue = dispatch_queue_create("serial", DISPATCH_QUEUE_SERIAL);//创建串行队列
    //异步函数执行
    dispatch_async(queue, ^{
        for (int i = 0; i<3; i++) {
            [NSThread sleepForTimeInterval:2];//暂停2秒,模拟耗时操作
            NSLog(@"任务1:%@",[NSThread currentThread]);
        }

    });
    //异步函数执行
    dispatch_async(queue, ^{
        for (int i = 0; i<3; i++) {
            [NSThread sleepForTimeInterval:2];//暂停2秒,模拟耗时操作
            NSLog(@"任务2:%@",[NSThread currentThread]);
        }
    });
    //异步函数执行
    dispatch_async(queue, ^{
        for (int i = 0; i<3; i++) {
            [NSThread sleepForTimeInterval:2];//暂停2秒,模拟耗时操作
            NSLog(@"任务3:%@",[NSThread currentThread]);
        }
    });
    NSLog(@"结束:%@",[NSThread currentThread]);
}

可见异步函数+串行队列中,开启了新的线程(只开启一条子线程),”开始”,”结束”直接执行了(异步函数不会做任何等待，可以继续执行任务),子线程中的任务一个个按顺序执行(串行队列每次只有一个任务被执行，任务一个接一个按顺序执行)

• 5.锁死(同步函数+串行队列)

//死锁
- (void)deadLock{
    NSLog(@"开始:%@",[NSThread currentThread]);
    dispatch_queue_t  queue = dispatch_queue_create("deadLock", DISPATCH_QUEUE_SERIAL);//创建串行队列
    //执行同步函数
    dispatch_sync(queue, ^{
        NSLog(@"任务1:%@",[NSThread currentThread]);
        //执行同步函数
        dispatch_sync(queue, ^{
            NSLog(@"任务2:%@",[NSThread currentThread]);
        });

    });
    NSLog(@"结束:%@",[NSThread currentThread]);

}

结果可见程序崩溃,并报错Thread 1: EXC_BAD_INSTRUCTION (code=EXC_I386_INVOP, subcode=0x0),”开始”和”任务1”执行了,然而”任务2”和”结束”并没有执行(“开始”在主队列中,此时串行队列同步执行会按顺序执行,然而由于是同步函数必须执行完当前任务才会往下执行,此时任务1中又在当前队列同步执行任务2,则此时又必须把任务2执行完才能往下执行任务1,所以队列中任务1和任务2都在执行(我是这么理解的),然而是同步函数必须一个执行完后才能执行另外一个,所以任务1就等任务2执行完,任务2就等任务1执行完,就造成了锁死)

• 6总结一下:
  1.同步异步表示能否开启线程,并且是否愿意等待.
  2.串行并发表示任务之心的方式串行就是按顺序执行,并发就是可以同时执行.
  3.死锁需满足的条件:(1).同步函数,(2)串行对了,(3)执行串行队列同步函数任务中又执行了当前队列的同步函数任务(简单理解是就是串行同步的block中又执行了串行同步函数);

线程间通信

开发过程中，我们一般在主线程里边进行UI刷新，例如：点击、滚动、拖拽等事件。我们通常把一些耗时的操作放在其他线程，比如说图片下载、文件上传等耗时操作。而当我们有时候在其他线程完成了耗时操作时，需要回到主线程，那么就用到了线程之间的通讯。

示例:从子线程回到主线程

  //1.创建子线程下载图片
    //异步函数并发队里执行下载等耗时操作
    dispatch_async(dispatch_get_global_queue(0, 0), ^{

        //1.1 确定url
        NSURL *url = [NSURL URLWithString:@"http://a.hiphotos.baidu.com/zhidao/wh%3D450%2C600/sign=da0ec79c738da9774e7a8e2f8561d42f/c83d70cf3bc79f3d6842e09fbaa1cd11738b29f9.jpg"];

        //1.2 下载二进制数据到本地
        NSData *imageData =  [NSData dataWithContentsOfURL:url];

        //1.3 转换图片
        UIImage *image = [UIImage imageWithData:imageData];
        //回主线程更新UI
        dispatch_sync(dispatch_get_main_queue(), ^{
            self.imageV.image = image;
        });

    });

其他用法

1.栅栏函数-dispatch_barrier_sync

GCD中还有个用来执行任务的函数：栅栏函数

void dispatch_barrier_sync(dispatch_queue_t queue,DISPATCH_NOESCAPE dispatch_block_t block);

我们有时需要异步执行两组操作，而且第一组操作执行完之后，才能开始执行第二组操作。这样我们就需要一个相当于栅栏一样的一个方法将两组异步执行的操作组给分割起来，当然这里的操作组里可以包含一个或多个任务。这就需要用到dispatch_barrier_async方法在两个操作组间形成栅栏。
dispatch_barrier_async函数会等待前边追加到并发队列中的任务全部执行完毕之后，再将指定的任务追加到该异步队列中。然后在dispatch_barrier_async函数追加的任务执行完毕之后，异步队列才恢复为一般动作，接着追加任务到该异步队列并开始执行。具体如下图所示：

在前面的任务执行结束后它才执行，而且它后面的任务等它执行完成之后才会执行
注意:这个queue不能是全局的并发队列

//栅栏函数,异步并发才有意义
- (void)barrier{
    NSLog(@"开始:%@",[NSThread currentThread]);
    dispatch_queue_t queue = dispatch_queue_create("concurrent", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        for (int i = 0; i<3; i++) {
            [NSThread sleepForTimeInterval:2];//暂停2秒,模拟耗时操作
            NSLog(@"任务1:%@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i<3; i++) {
            [NSThread sleepForTimeInterval:2];//暂停2秒,模拟耗时操作
            NSLog(@"任务2:%@",[NSThread currentThread]);
        }
    });

    dispatch_barrier_sync(queue, ^{
        NSLog(@"栅栏函数:%@",[NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        for (int i = 0; i<3; i++) {
            [NSThread sleepForTimeInterval:2];//暂停2秒,模拟耗时操作
            NSLog(@"任务3:%@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i<3; i++) {
            [NSThread sleepForTimeInterval:2];//暂停2秒,模拟耗时操作
            NSLog(@"任务4:%@",[NSThread currentThread]);
        }
    });
    NSLog(@"结束:%@",[NSThread currentThread]);

}

可见栅栏函数前面的任务是并发执行,后面的任务也是并发执行,但是整体的顺序并没有乱,但是如果是全局并发队列,则栅栏函数无效;

dispatch_queue_t queue = dispatch_get_global_queue(0, 0);

结果可见,如果是全局并发队列,栅栏函数失效

2 .延时执行-dispatch_after

GCD 延时执行方法：dispatch_after
dispatch_after函数并不是在指定时间之后才开始执行处理，而是在指定时间之后将任务追加到主队列中。严格来说，这个时间并不是绝对准确的，但想要大致延迟执行任务，dispatch_after函数是很有效的。

//方法1:调用NSObject的方法
 - (void)performSelector:(SEL)aSelector withObject:(nullable id)anArgument afterDelay:(NSTimeInterval)delay;
//方法2:使用NSTimer
 + (NSTimer *)scheduledTimerWithTimeInterval:(NSTimeInterval)ti target:(id)aTarget selector:(SEL)aSelector userInfo:(nullable id)userInfo repeats:(BOOL)yesOrNo;
//方法3:使用GCD函数
 void dispatch_after(dispatch_time_t when,dispatch_queue_t queue,dispatch_block_t block);

3.一次性代码-dispatch_once

我们在创建单例、或者有整个程序运行过程中只执行一次的代码时，我们就用到了 GCD 的 dispatch_once 函数。使用dispatch_once 函数能保证某段代码在程序运行过程中只被执行1次，并且即使在多线程的环境下，dispatch_once也可以保证线程安全。

//整个程序运行过程中只会执行一次
//onceToken用来记录该部分的代码是否被执行过
 static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        <#code to be executed once#>
 // 只执行1次的代码(这里面默认是线程安全的)
    });

注意 :不能放到懒加载

4.快速迭代遍历-dispatch_apply

GCD 给我们提供了快速迭代的函数dispatch_apply。dispatch_apply按照指定的次数将指定的任务追加到指定的队列中，并等待全部队列执行结束。
如果是在串行队列中使用 dispatch_apply，那么就和 for 循环一样，按顺序同步执行。可这样就体现不出快速迭代的意义了。dispatch_apply 可以 在多个线程中同时（异步）遍历多个数字。还有一点，无论是在串行队列，还是异步队列中，dispatch_apply 都会等待全部任务执行完毕，这点就像是同步操作，也像是队列组中的 dispatch_group_wait方法。

void dispatch_apply(size_t iterations, dispatch_queue_t queue,
        DISPATCH_NOESCAPE void (^block)(size_t));
参数:
size_t iterations : 遍历次数
dispatch_queue_t queue : 队列
size_t:索引

5. 队列组-dispatch_group

有时候我们会有这样的需求：分别异步执行2个耗时任务，然后当2个耗时任务都执行完毕后再回到主线程执行任务。这时候我们可以用到 GCD 的队列组。

//创建队列组
dispatch_group_t group = dispatch_group_create();  
//监听 group 中任务的完成状态，当所有的任务都执行完成后，追加任务到 group 中，并执行任务
dispatch_group_notify(dispatch_group_t group,dispatch_queue_t queue,dispatch_block_t block);
dispatch_group_enter(group);//执行该函数后，后面异步执行的block会被gruop监听
dispatch_group_leave(group);//异步block中，所有的任务都执行完毕，最后离开群组
//注意：dispatch_group_enter|dispatch_group_leave必须成对使用
//暂停当前线程（阻塞当前线程），等待指定的 group 中的任务执行完成后，才会往下继续执行。
dispatch_group_wait

示例:下载多张图片,合并图片并显示

 dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    dispatch_group_t group = dispatch_group_create();
    //开子线程下载图片
    dispatch_group_async(group, queue, ^{
        NSURL * url = [NSURL URLWithString:@"http://www.qbaobei.com/tuku/images/13.jpg"];
        NSData * imageData = [NSData dataWithContentsOfURL:url];
        self.image1 = [UIImage imageWithData:imageData];
    });
    dispatch_group_async(group, queue, ^{
        NSURL * url = [NSURL URLWithString:@"https://ss0.baidu.com/6ONWsjip0QIZ8tyhnq/it/u=1369772073,1626501516&fm=175&s=D391718F74836EEC5218B1D90300F0A9&w=640&h=427&img.JPEG"];
        NSData * imageData = [NSData dataWithContentsOfURL:url];
        self.image2 = [UIImage imageWithData:imageData];
    });
    //下载完成后回主线程合并图片并刷新UI
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        //开启上下文
        UIGraphicsBeginImageContext(CGSizeMake(200, 200));
        //将图片1,2加入到上下文中
        [self.image1 drawInRect:CGRectMake(0, 0, 200, 100)];
        [self.image2 drawInRect:CGRectMake(0, 100, 200, 100)];
        //根据上下文获取图片
        UIImage * image = UIGraphicsGetImageFromCurrentImageContext();
        //关闭上下文
        UIGraphicsEndImageContext();
        self.imageView.image = image;
    });

6.GCD 信号量-dispatch_semaphore

• GCD 中的信号量是指 Dispatch Semaphore，是持有计数的信号。类似于过高速路收费站的栏杆。可以通过时，打开栏杆，不可以通过时，关闭栏杆。在 Dispatch Semaphore 中，使用计数来完成这个功能，计数为0时等待，不可通过。计数为1或大于1时，计数减1且不等待，可通过。
  Dispatch Semaphore 提供了三个函数。
  dispatch_semaphore_create：创建一个Semaphore并初始化信号的总量
  dispatch_semaphore_signal：发送一个信号，让信号总量加1
  dispatch_semaphore_wait：可以使总信号量减1，当信号总量为0时就会一直等待（阻塞所在线程），否则就可以正常执行。
• 注意：信号量的使用前提是：想清楚你需要处理哪个线程等待（阻塞），又要哪个线程继续执行，然后使用信号量。
• Dispatch Semaphore 在实际开发中主要用于：
  
  1. 保持线程同步，将异步执行任务转换为同步执行任务
  2. 保证线程安全，为线程加锁

7. Dispatch Semaphore 线程同步

• 我们在开发中，会遇到这样的需求：异步执行耗时任务，并使用异步执行的结果进行一些额外的操作。换句话说，相当于，将将异步执行任务转换为同步执行任务。比如说：AFNetworking 中 AFURLSessionManager.m 里面的 tasksForKeyPath: 方法。通过引入信号量的方式，等待异步执行任务结果，获取到 tasks，然后再返回该 tasks。

- (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实现线程同步，将异步执行任务转换为同步执行任务。

- (void)semaphoreSync{
    NSLog(@"begin：%@",[NSThread currentThread]);
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);//获取全局并发队列
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);//初始化信号量为0
      __block int number = 0;
    dispatch_async(queue, ^{//异步执行
        NSLog(@"1---%@",[NSThread currentThread]);// 打印当前线程
        number = 100;
        dispatch_semaphore_signal(semaphore);//发送一个信号，让信号总量加1
    });
    NSLog(@"继续：%@",[NSThread currentThread]);
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);//可以使总信号量减1，当信号总量为0时就会一直等待（阻塞所在线程），否则就可以正常执行。
    NSLog(@"end，number = %zd",number);
}

结果可见：最后打印的结果为”end，number = 100”；这是因为异步执行不会做任何等待，可以继续执行任务。异步执行将任务追加到队列之后，不做等待，接着执行dispatch_semaphore_wait方法。此时 semaphore == 0，当前线程进入等待状态。然后，异步block开始执行。任务执行到dispatch_semaphore_signal之后，总信号量，此时 semaphore == 1，dispatch_semaphore_wait方法使总信号量减1，正在被阻塞的线程（主线程）恢复继续执行，这样就实现了线程同步，将异步执行任务转换为同步执行任务（类似如CGD的栅栏函数和NSOperation的依赖）

8. 线程安全（为线程加锁)

• 线程安全：如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
• 若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作（增删改），一般都需要考虑线程同步，否则的话就可能影响线程安全。
• 我们模拟火车票售卖的方式，实现 NSOperation 线程安全和解决线程同步问题。场景：总共有20张火车票，有两个售卖火车票的窗口，一个是北京火车票售卖窗口，另一个是上海火车票售卖窗口。两个窗口同时售卖火车票，卖完为止。

(1)非线程安全（不使用 semaphore）

-(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
    [self initUnsafeSaleTickets];
}
static NSInteger totalNum;
- (void)initUnsafeSaleTickets{
    totalNum = 20;
    //创建两个串行队列分别代表北京上海两个售票口
    dispatch_queue_t beijingQ = dispatch_queue_create("beijingQ", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t shanghaiQ = dispatch_queue_create("shanghaiQ", DISPATCH_QUEUE_SERIAL);
    __weak typeof(self)weakSelf = self;
    //异步执行售票任务
    dispatch_async(beijingQ, ^{
        [weakSelf unsafeSaleTicketsWithWindow:@"北京"];
    });
    dispatch_async(shanghaiQ, ^{
        [weakSelf unsafeSaleTicketsWithWindow:@"上海"];
    });
}
-(void)unsafeSaleTicketsWithWindow:(NSString *)windowName{
    while (1) {
        if (totalNum) {
            // 每卖一张票，总票数就少一张
            totalNum -- ;
            NSLog(@"%@窗口出售了一张票(线程：%@)，还剩%zd张票",windowName,[NSThread currentThread],totalNum);
        }else{
            NSLog(@"票已经卖完");
            break;
        }
    }
}

结果可见：不考虑线程安全的情况下，出现的错了的数据，不是我们想要的结果。

(2)线程安全（使用 semaphore 加锁）

dispatch_semaphore_t semaphoreLock;//信号量锁
- (void)initSafeSaleTickets{
    totalNum = 20;
    semaphoreLock = dispatch_semaphore_create(1);//初始化信号量为1

    //创建两个串行队列分别代表北京上海两个售票口
    dispatch_queue_t beijingQ = dispatch_queue_create("beijingQ", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t shanghaiQ = dispatch_queue_create("shanghaiQ", DISPATCH_QUEUE_SERIAL);
    __weak typeof(self)weakSelf = self;
    //异步执行售票任务
    dispatch_async(beijingQ, ^{
        [weakSelf safeSaleTicketsWithWindow:@"北京"];
    });
    dispatch_async(shanghaiQ, ^{
        [weakSelf safeSaleTicketsWithWindow:@"上海"];
    });
}
-(void)safeSaleTicketsWithWindow:(NSString *)windowName{
    while (1) {
        //枷锁。枷锁后的代码只能同步执行，即只能一次执行完后才能执行下一次
        dispatch_semaphore_wait(semaphoreLock, DISPATCH_TIME_FOREVER);
        if (totalNum) {
            // 每卖一张票，总票数就少一张
            totalNum -- ;
            NSLog(@"%@窗口出售了一张票(线程：%@)，还剩%zd张票",windowName,[NSThread currentThread],totalNum);
        }else{
            NSLog(@"票已经卖完");
            break;
        }
        dispatch_semaphore_signal(semaphoreLock);//解锁
    }
}

结果可见：售票数据没出现错乱，线程是安全的。

---

参考文章:
iOS GCD之dispatch_semaphore（信号量)
iOS多线程：『GCD』详尽总结
GCDAPI
Libdispatch版本源码

---

iOS多线程相关文章:
iOS多线程简述
iOS多线程-pthread、NSThread
iOS多线程-GCD
iOS多线程-NSOperation, NSOperationQueue
iOS多线程-RunLoop
OC单例模式详解