GCD

本文用来介绍ios多线程中gcd的相关知识以及使用方法。这大概是史上最详细、清晰的关于gcd的详细讲解+总结的文章了。通过本文，您将了解到：1.gcd简介2.gcd任务和队列3.gcd的使用步骤4.gcd的基本使用（6种不同组合区别）5.gcd线程间的通信6.gcd的其他方法（栅栏方法：dispatch_barrier_async、延时执行方法：dispatch_after、一次性代码（只执行一次）：dispatch_once、快速迭代方法：dispatch_apply、队列组：dispatch_group、信号量：dispatch_semaphore）

文中demo我已放在了github上，demo链接：传送门

什么是gcd呢？我们先来看看百度百科的解释简单了解下概念

引自百度百科grandcentraldispatch(gcd)是apple开发的一个多核编程的较新的解决方法。它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。它是一个在线程池模式的基础上执行的并发任务。在macosx10.6雪豹中首次推出，也可在ios4及以上版本使用。

为什么要用gcd呢？

因为gcd有很多好处啊，具体如下：

既然gcd有这么多的好处，那么下面我们就来系统的学习一下gcd的使用方法。

学习gcd之前，先来了解gcd中两个核心概念：任务和队列。

任务：就是执行操作的意思，换句话说就是你在线程中执行的那段代码。在gcd中是放在block中的。执行任务有两种方式：同步执行（sync）和异步执行（async）。两者的主要区别是：是否等待队列的任务执行结束，以及是否具备开启新线程的能力。

举个简单例子：你要打电话给小明和小白。同步执行就是，你打电话给小明的时候，不能同时打给小白，等到给小明打完了，才能打给小白（等待任务执行结束）。而且只能用当前的电话（不具备开启新线程的能力）。而异步执行就是，你打电话给小明的时候，不等和小明通话结束，还能直接给小白打电话，不用等着和小明通话结束再打（不用等待任务执行结束）。除了当前电话，你还可以使用其他所能使用的电话（具备开启新线程的能力）。

注意：异步执行（async）虽然具有开启新线程的能力，但是并不一定开启新线程。这跟任务所指定的队列类型有关（下面会讲）。

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

在gcd中有两种队列：串行队列和并发队列。两者都符合fifo（先进先出）的原则。两者的主要区别是：执行顺序不同，以及开启线程数不同。

注意：并发队列的并发功能只有在异步（dispatch_async）函数下才有效

两者具体区别如下两图所示。

gcd的使用步骤其实很简单，只有两步。

下边来看看队列的创建方法/获取方法，以及任务的创建方法。

1234

//串行队列的创建方法dispatch_queue_tqueue=dispatch_queue_create("net.bujige.testqueue",dispatch_queue_serial);//并发队列的创建方法dispatch_queue_tqueue=dispatch_queue_create("net.bujige.testqueue",dispatch_queue_concurrent);对于串行队列，gcd提供了的一种特殊的串行队列：主队列（maindispatchqueue）。所有放在主队列中的任务，都会放到主线程中执行。可使用dispatch_get_main_queue()获得主队列。

12

//主队列的获取方法dispatch_queue_tqueue=dispatch_get_main_queue();对于并发队列，gcd默认提供了全局并发队列（globaldispatchqueue）。可以使用dispatch_get_global_queue来获取。需要传入两个参数。第一个参数表示队列优先级，一般用dispatch_queue_priority_default。第二个参数暂时没用，用0即可。

12

//全局并发队列的获取方法dispatch_queue_tqueue=dispatch_get_global_queue(dispatch_queue_priority_default,0);3.2任务的创建方法

gcd提供了同步执行任务的创建方法dispatch_sync和异步执行任务创建方法dispatch_async。

12345678

//同步执行任务创建方法dispatch_sync(queue,^{//这里放同步执行任务代码});//异步执行任务创建方法dispatch_async(queue,^{//这里放异步执行任务代码});

虽然使用gcd只需两步，但是既然我们有两种队列（串行队列/并发队列），两种任务执行方式（同步执行/异步执行），那么我们就有了四种不同的组合方式。这四种不同的组合方式是：

实际上，刚才还说了两种特殊队列：全局并发队列、主队列。全局并发队列可以作为普通并发队列来使用。但是主队列因为有点特殊，所以我们就又多了两种组合方式。这样就有六种不同的组合方式了。

那么这几种不同组合方式各有什么区别呢，这里为了方便，先上结果，再来讲解。你可以直接查看表格结果，然后跳过4.gcd的基本使用。

下边我们来分别讲讲这几种不同的组合方式的使用方法。

先来讲讲并发队列的两种执行方式。

123456789101112131415161718192021222324252627282930313233343536

/***同步执行+并发队列*特点：在当前线程中执行任务，不会开启新线程，执行完一个任务，再执行下一个任务。*/-(void)syncconcurrent{nslog(@"currentthread---%@",[nsthreadcurrentthread]);//打印当前线程nslog(@"syncconcurrent---begin");dispatch_queue_tqueue=dispatch_queue_create("net.bujige.testqueue",dispatch_queue_concurrent);dispatch_sync(queue,^{//追加任务1for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"1---%@",[nsthreadcurrentthread]);//打印当前线程}});dispatch_sync(queue,^{//追加任务2for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"2---%@",[nsthreadcurrentthread]);//打印当前线程}});dispatch_sync(queue,^{//追加任务3for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"3---%@",[nsthreadcurrentthread]);//打印当前线程}});nslog(@"syncconcurrent---end");}

输出结果：2018-02-2320:34:55.095932+0800ysc-gcd-demo[19892:4996930]currentthread—{number=1,name=main}2018-02-2320:34:55.096086+0800ysc-gcd-demo[19892:4996930]syncconcurrent—begin2018-02-2320:34:57.097589+0800ysc-gcd-demo[19892:4996930]1—{number=1,name=main}2018-02-2320:34:59.099100+0800ysc-gcd-demo[19892:4996930]1—{number=1,name=main}2018-02-2320:35:01.099843+0800ysc-gcd-demo[19892:4996930]2—{number=1,name=main}2018-02-2320:35:03.101171+0800ysc-gcd-demo[19892:4996930]2—{number=1,name=main}2018-02-2320:35:05.101750+0800ysc-gcd-demo[19892:4996930]3—{number=1,name=main}2018-02-2320:35:07.102414+0800ysc-gcd-demo[19892:4996930]3—{number=1,name=main}2018-02-2320:35:07.102575+0800ysc-gcd-demo[19892:4996930]syncconcurrent—end

从同步执行+并发队列中可看到：

123456789101112131415161718192021222324252627282930313233343536

/***异步执行+并发队列*特点：可以开启多个线程，任务交替（同时）执行。*/-(void)asyncconcurrent{nslog(@"currentthread---%@",[nsthreadcurrentthread]);//打印当前线程nslog(@"asyncconcurrent---begin");dispatch_queue_tqueue=dispatch_queue_create("net.bujige.testqueue",dispatch_queue_concurrent);dispatch_async(queue,^{//追加任务1for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"1---%@",[nsthreadcurrentthread]);//打印当前线程}});dispatch_async(queue,^{//追加任务2for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"2---%@",[nsthreadcurrentthread]);//打印当前线程}});dispatch_async(queue,^{//追加任务3for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"3---%@",[nsthreadcurrentthread]);//打印当前线程}});nslog(@"asyncconcurrent---end");}

输出结果：2018-02-2320:36:41.769269+0800ysc-gcd-demo[19929:5005237]currentthread—{number=1,name=main}2018-02-2320:36:41.769496+0800ysc-gcd-demo[19929:5005237]asyncconcurrent—begin2018-02-2320:36:41.769725+0800ysc-gcd-demo[19929:5005237]asyncconcurrent—end2018-02-2320:36:43.774442+0800ysc-gcd-demo[19929:5005566]2—{number=5,name=(null)}2018-02-2320:36:43.774440+0800ysc-gcd-demo[19929:5005567]3—{number=4,name=(null)}2018-02-2320:36:43.774440+0800ysc-gcd-demo[19929:5005565]1—{number=3,name=(null)}2018-02-2320:36:45.779286+0800ysc-gcd-demo[19929:5005567]3—{number=4,name=(null)}2018-02-2320:36:45.779302+0800ysc-gcd-demo[19929:5005565]1—{number=3,name=(null)}2018-02-2320:36:45.779286+0800ysc-gcd-demo[19929:5005566]2—{number=5,name=(null)}

在异步执行+并发队列中可以看出：

接下来再来讲讲串行队列的两种执行方式。

12345678910111213141516171819202122232425262728293031323334

/***同步执行+串行队列*特点：不会开启新线程，在当前线程执行任务。任务是串行的，执行完一个任务，再执行下一个任务。*/-(void)syncserial{nslog(@"currentthread---%@",[nsthreadcurrentthread]);//打印当前线程nslog(@"syncserial---begin");dispatch_queue_tqueue=dispatch_queue_create("net.bujige.testqueue",dispatch_queue_serial);dispatch_sync(queue,^{//追加任务1for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"1---%@",[nsthreadcurrentthread]);//打印当前线程}});dispatch_sync(queue,^{//追加任务2for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"2---%@",[nsthreadcurrentthread]);//打印当前线程}});dispatch_sync(queue,^{//追加任务3for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"3---%@",[nsthreadcurrentthread]);//打印当前线程}});nslog(@"syncserial---end");}

输出结果为：2018-02-2320:39:37.876811+0800ysc-gcd-demo[19975:5017162]currentthread—{number=1,name=main}2018-02-2320:39:37.876998+0800ysc-gcd-demo[19975:5017162]syncserial—begin2018-02-2320:39:39.878316+0800ysc-gcd-demo[19975:5017162]1—{number=1,name=main}2018-02-2320:39:41.879829+0800ysc-gcd-demo[19975:5017162]1—{number=1,name=main}2018-02-2320:39:43.880660+0800ysc-gcd-demo[19975:5017162]2—{number=1,name=main}2018-02-2320:39:45.881265+0800ysc-gcd-demo[19975:5017162]2—{number=1,name=main}2018-02-2320:39:47.882257+0800ysc-gcd-demo[19975:5017162]3—{number=1,name=main}2018-02-2320:39:49.883008+0800ysc-gcd-demo[19975:5017162]3—{number=1,name=main}2018-02-2320:39:49.883253+0800ysc-gcd-demo[19975:5017162]syncserial—end

在同步执行+串行队列可以看到：

12345678910111213141516171819202122232425262728293031323334

/***异步执行+串行队列*特点：会开启新线程，但是因为任务是串行的，执行完一个任务，再执行下一个任务。*/-(void)asyncserial{nslog(@"currentthread---%@",[nsthreadcurrentthread]);//打印当前线程nslog(@"asyncserial---begin");dispatch_queue_tqueue=dispatch_queue_create("net.bujige.testqueue",dispatch_queue_serial);dispatch_async(queue,^{//追加任务1for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"1---%@",[nsthreadcurrentthread]);//打印当前线程}});dispatch_async(queue,^{//追加任务2for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"2---%@",[nsthreadcurrentthread]);//打印当前线程}});dispatch_async(queue,^{//追加任务3for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"3---%@",[nsthreadcurrentthread]);//打印当前线程}});nslog(@"asyncserial---end");}

输出结果为：2018-02-2320:41:17.029999+0800ysc-gcd-demo[20008:5024757]currentthread—{number=1,name=main}2018-02-2320:41:17.030212+0800ysc-gcd-demo[20008:5024757]asyncserial—begin2018-02-2320:41:17.030364+0800ysc-gcd-demo[20008:5024757]asyncserial—end2018-02-2320:41:19.035379+0800ysc-gcd-demo[20008:5024950]1—{number=3,name=(null)}2018-02-2320:41:21.037140+0800ysc-gcd-demo[20008:5024950]1—{number=3,name=(null)}2018-02-2320:41:23.042220+0800ysc-gcd-demo[20008:5024950]2—{number=3,name=(null)}2018-02-2320:41:25.042971+0800ysc-gcd-demo[20008:5024950]2—{number=3,name=(null)}2018-02-2320:41:27.047690+0800ysc-gcd-demo[20008:5024950]3—{number=3,name=(null)}2018-02-2320:41:29.052327+0800ysc-gcd-demo[20008:5024950]3—{number=3,name=(null)}

在异步执行+串行队列可以看到：

下边讲讲刚才我们提到过的特殊队列：主队列。

我们再来看看主队列的两种组合方式。

同步执行+主队列在不同线程中调用结果也是不一样，在主线程中调用会出现死锁，而在其他线程中则不会。

1234567891011121314151617181920212223242526272829303132333435363738

/***同步执行+主队列*特点(主线程调用)：互等卡主不执行。*特点(其他线程调用)：不会开启新线程，执行完一个任务，再执行下一个任务。*/-(void)syncmain{nslog(@"currentthread---%@",[nsthreadcurrentthread]);//打印当前线程nslog(@"syncmain---begin");dispatch_queue_tqueue=dispatch_get_main_queue();dispatch_sync(queue,^{//追加任务1for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"1---%@",[nsthreadcurrentthread]);//打印当前线程}});dispatch_sync(queue,^{//追加任务2for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"2---%@",[nsthreadcurrentthread]);//打印当前线程}});dispatch_sync(queue,^{//追加任务3for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"3---%@",[nsthreadcurrentthread]);//打印当前线程}});nslog(@"syncmain---end");}

输出结果2018-02-2320:42:36.842892+0800ysc-gcd-demo[20041:5030982]currentthread—{number=1,name=main}2018-02-2320:42:36.843050+0800ysc-gcd-demo[20041:5030982]syncmain—begin(lldb)

在同步执行+主队列可以惊奇的发现：

这是因为我们在主线程中执行syncmain方法，相当于把syncmain任务放到了主线程的队列中。而同步执行会等待当前队列中的任务执行完毕，才会接着执行。那么当我们把任务1追加到主队列中，任务1就在等待主线程处理完syncmain任务。而syncmain任务需要等待任务1执行完毕，才能接着执行。

那么，现在的情况就是syncmain任务和任务1都在等对方执行完毕。这样大家互相等待，所以就卡住了，所以我们的任务执行不了，而且syncmain---end也没有打印。

要是如果不在主线程中调用，而在其他线程中调用会如何呢？

123

//使用nsthread的detachnewthreadselector方法会创建线程，并自动启动线程执行selector任务[nsthreaddetachnewthreadselector:@selector(syncmain)totarget:selfwithobject:nil];

输出结果：2018-02-2320:44:19.377321+0800ysc-gcd-demo[20083:5040347]currentthread—{number=3,name=(null)}2018-02-2320:44:19.377494+0800ysc-gcd-demo[20083:5040347]syncmain—begin2018-02-2320:44:21.384716+0800ysc-gcd-demo[20083:5040132]1—{number=1,name=main}2018-02-2320:44:23.386091+0800ysc-gcd-demo[20083:5040132]1—{number=1,name=main}2018-02-2320:44:25.387687+0800ysc-gcd-demo[20083:5040132]2—{number=1,name=main}2018-02-2320:44:27.388648+0800ysc-gcd-demo[20083:5040132]2—{number=1,name=main}2018-02-2320:44:29.390459+0800ysc-gcd-demo[20083:5040132]3—{number=1,name=main}2018-02-2320:44:31.391965+0800ysc-gcd-demo[20083:5040132]3—{number=1,name=main}2018-02-2320:44:31.392513+0800ysc-gcd-demo[20083:5040347]syncmain—end

在其他线程中使用同步执行+主队列可看到：

为什么现在就不会卡住了呢？因为syncmain任务放到了其他线程里，而任务1、任务2、任务3都在追加到主队列中，这三个任务都会在主线程中执行。syncmain任务在其他线程中执行到追加任务1到主队列中，因为主队列现在没有正在执行的任务，所以，会直接执行主队列的任务1，等任务1执行完毕，再接着执行任务2、任务3。所以这里不会卡住线程。

123456789101112131415161718192021222324252627282930313233343536

/***异步执行+主队列*特点：只在主线程中执行任务，执行完一个任务，再执行下一个任务*/-(void)asyncmain{nslog(@"currentthread---%@",[nsthreadcurrentthread]);//打印当前线程nslog(@"asyncmain---begin");dispatch_queue_tqueue=dispatch_get_main_queue();dispatch_async(queue,^{//追加任务1for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"1---%@",[nsthreadcurrentthread]);//打印当前线程}});dispatch_async(queue,^{//追加任务2for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"2---%@",[nsthreadcurrentthread]);//打印当前线程}});dispatch_async(queue,^{//追加任务3for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"3---%@",[nsthreadcurrentthread]);//打印当前线程}});nslog(@"asyncmain---end");}

输出结果：2018-02-2320:45:49.981505+0800ysc-gcd-demo[20111:5046708]currentthread—{number=1,name=main}2018-02-2320:45:49.981935+0800ysc-gcd-demo[20111:5046708]asyncmain—begin2018-02-2320:45:49.982352+0800ysc-gcd-demo[20111:5046708]asyncmain—end2018-02-2320:45:51.991096+0800ysc-gcd-demo[20111:5046708]1—{number=1,name=main}2018-02-2320:45:53.991959+0800ysc-gcd-demo[20111:5046708]1—{number=1,name=main}2018-02-2320:45:55.992937+0800ysc-gcd-demo[20111:5046708]2—{number=1,name=main}2018-02-2320:45:57.993649+0800ysc-gcd-demo[20111:5046708]2—{number=1,name=main}2018-02-2320:45:59.994928+0800ysc-gcd-demo[20111:5046708]3—{number=1,name=main}2018-02-2320:46:01.995589+0800ysc-gcd-demo[20111:5046708]3—{number=1,name=main}

在异步执行+主队列可以看到：

弄懂了难理解、绕来绕去的队列+任务之后，我们来学习一个简单的东西：5.gcd线程间的通信。

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

123456789101112131415161718192021222324

/***线程间通信*/-(void)communication{//获取全局并发队列dispatch_queue_tqueue=dispatch_get_global_queue(dispatch_queue_priority_default,0);//获取主队列dispatch_queue_tmainqueue=dispatch_get_main_queue();dispatch_async(queue,^{//异步追加任务for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"1---%@",[nsthreadcurrentthread]);//打印当前线程}//回到主线程dispatch_async(mainqueue,^{//追加在主线程中执行的任务[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"2---%@",[nsthreadcurrentthread]);//打印当前线程});});}

输出结果：2018-02-2320:47:03.462394+0800ysc-gcd-demo[20154:5053282]1—{number=3,name=(null)}2018-02-2320:47:05.465912+0800ysc-gcd-demo[20154:5053282]1—{number=3,name=(null)}2018-02-2320:47:07.466657+0800ysc-gcd-demo[20154:5052953]2—{number=1,name=main}

1234567891011121314151617181920212223242526272829303132333435363738394041424344

/***栅栏方法dispatch_barrier_async*/-(void)barrier{dispatch_queue_tqueue=dispatch_queue_create("net.bujige.testqueue",dispatch_queue_concurrent);dispatch_async(queue,^{//追加任务1for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"1---%@",[nsthreadcurrentthread]);//打印当前线程}});dispatch_async(queue,^{//追加任务2for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"2---%@",[nsthreadcurrentthread]);//打印当前线程}});dispatch_barrier_async(queue,^{//追加任务barrierfor(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"barrier---%@",[nsthreadcurrentthread]);//打印当前线程}});dispatch_async(queue,^{//追加任务3for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"3---%@",[nsthreadcurrentthread]);//打印当前线程}});dispatch_async(queue,^{//追加任务4for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"4---%@",[nsthreadcurrentthread]);//打印当前线程}});}

输出结果：2018-02-2320:48:18.297745+0800ysc-gcd-demo[20188:5059274]1—{number=4,name=(null)}2018-02-2320:48:18.297745+0800ysc-gcd-demo[20188:5059273]2—{number=3,name=(null)}2018-02-2320:48:20.301139+0800ysc-gcd-demo[20188:5059274]1—{number=4,name=(null)}2018-02-2320:48:20.301139+0800ysc-gcd-demo[20188:5059273]2—{number=3,name=(null)}2018-02-2320:48:22.306290+0800ysc-gcd-demo[20188:5059274]barrier—{number=4,name=(null)}2018-02-2320:48:24.311655+0800ysc-gcd-demo[20188:5059274]barrier—{number=4,name=(null)}2018-02-2320:48:26.316943+0800ysc-gcd-demo[20188:5059273]4—{number=3,name=(null)}2018-02-2320:48:26.316956+0800ysc-gcd-demo[20188:5059274]3—{number=4,name=(null)}2018-02-2320:48:28.320660+0800ysc-gcd-demo[20188:5059273]4—{number=3,name=(null)}2018-02-2320:48:28.320649+0800ysc-gcd-demo[20188:5059274]3—{number=4,name=(null)}

在dispatch_barrier_async执行结果中可以看出：

我们经常会遇到这样的需求：在指定时间（例如3秒）之后执行某个任务。可以用gcd的dispatch_after函数来实现。需要注意的是：dispatch_after函数并不是在指定时间之后才开始执行处理，而是在指定时间之后将任务追加到主队列中。严格来说，这个时间并不是绝对准确的，但想要大致延迟执行任务，dispatch_after函数是很有效的。

123456789101112

/***延时执行方法dispatch_after*/-(void)after{nslog(@"currentthread---%@",[nsthreadcurrentthread]);//打印当前线程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---%@",[nsthreadcurrentthread]);//打印当前线程});}

输出结果：2018-02-2320:53:08.713784+0800ysc-gcd-demo[20282:5080295]currentthread—{number=1,name=main}2018-02-2320:53:08.713962+0800ysc-gcd-demo[20282:5080295]asyncmain—begin2018-02-2320:53:10.714283+0800ysc-gcd-demo[20282:5080295]after—{number=1,name=main}

可以看出：在打印asyncmain---begin之后大约2.0秒的时间，打印了after---{number=1,name=main}

123456789

/***一次性代码（只执行一次）dispatch_once*/-(void)once{staticdispatch_once_toncetoken;dispatch_once(&oncetoken,^{//只执行1次的代码(这里面默认是线程安全的)});}6.4gcd快速迭代方法：dispatch_apply通常我们会用for循环遍历，但是gcd给我们提供了快速迭代的函数dispatch_apply。dispatch_apply按照指定的次数将指定的任务追加到指定的队列中，并等待全部队列执行结束。

如果是在串行队列中使用dispatch_apply，那么就和for循环一样，按顺序同步执行。可这样就体现不出快速迭代的意义了。我们可以利用并发队列进行异步执行。比如说遍历0~5这6个数字，for循环的做法是每次取出一个元素，逐个遍历。dispatch_apply可以在多个线程中同时（异步）遍历多个数字。还有一点，无论是在串行队列，还是异步队列中，dispatch_apply都会等待全部任务执行完毕，这点就像是同步操作，也像是队列组中的dispatch_group_wait方法。

123456789101112

/***快速迭代方法dispatch_apply*/-(void)apply{dispatch_queue_tqueue=dispatch_get_global_queue(dispatch_queue_priority_default,0);nslog(@"apply---begin");dispatch_apply(6,queue,^(size_tindex){nslog(@"%zd---%@",index,[nsthreadcurrentthread]);});nslog(@"apply---end");}

输出结果：2018-02-2322:03:18.475499+0800ysc-gcd-demo[20470:5176805]apply—begin2018-02-2322:03:18.476672+0800ysc-gcd-demo[20470:5177035]1—{number=3,name=(null)}2018-02-2322:03:18.476693+0800ysc-gcd-demo[20470:5176805]0—{number=1,name=main}2018-02-2322:03:18.476704+0800ysc-gcd-demo[20470:5177037]2—{number=4,name=(null)}2018-02-2322:03:18.476735+0800ysc-gcd-demo[20470:5177036]3—{number=5,name=(null)}2018-02-2322:03:18.476867+0800ysc-gcd-demo[20470:5177035]4—{number=3,name=(null)}2018-02-2322:03:18.476867+0800ysc-gcd-demo[20470:5176805]5—{number=1,name=main}2018-02-2322:03:18.477038+0800ysc-gcd-demo[20470:5176805]apply—end

因为是在并发队列中异步队执行任务，所以各个任务的执行时间长短不定，最后结束顺序也不定。但是apply---end一定在最后执行。这是因为dispatch_apply函数会等待全部任务执行完毕。

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

12345678910111213141516171819202122232425262728293031323334

/***队列组dispatch_group_notify*/-(void)groupnotify{nslog(@"currentthread---%@",[nsthreadcurrentthread]);//打印当前线程nslog(@"group---begin");dispatch_group_tgroup=dispatch_group_create();dispatch_group_async(group,dispatch_get_global_queue(dispatch_queue_priority_default,0),^{//追加任务1for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"1---%@",[nsthreadcurrentthread]);//打印当前线程}});dispatch_group_async(group,dispatch_get_global_queue(dispatch_queue_priority_default,0),^{//追加任务2for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"2---%@",[nsthreadcurrentthread]);//打印当前线程}});dispatch_group_notify(group,dispatch_get_main_queue(),^{//等前面的异步任务1、任务2都执行完毕后，回到主线程执行下边任务for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"3---%@",[nsthreadcurrentthread]);//打印当前线程}nslog(@"group---end");});}

输出结果：2018-02-2322:05:03.790035+0800ysc-gcd-demo[20494:5183349]currentthread—{number=1,name=main}2018-02-2322:05:03.790237+0800ysc-gcd-demo[20494:5183349]group—begin2018-02-2322:05:05.792721+0800ysc-gcd-demo[20494:5183654]1—{number=4,name=(null)}2018-02-2322:05:05.792725+0800ysc-gcd-demo[20494:5183656]2—{number=3,name=(null)}2018-02-2322:05:07.797408+0800ysc-gcd-demo[20494:5183656]2—{number=3,name=(null)}2018-02-2322:05:07.797408+0800ysc-gcd-demo[20494:5183654]1—{number=4,name=(null)}2018-02-2322:05:09.798717+0800ysc-gcd-demo[20494:5183349]3—{number=1,name=main}2018-02-2322:05:11.799827+0800ysc-gcd-demo[20494:5183349]3—{number=1,name=main}2018-02-2322:05:11.799977+0800ysc-gcd-demo[20494:5183349]group—end

从dispatch_group_notify相关代码运行输出结果可以看出：当所有任务都执行完成之后，才执行dispatch_group_notifyblock中的任务。

123456789101112131415161718192021222324252627282930

/***队列组dispatch_group_wait*/-(void)groupwait{nslog(@"currentthread---%@",[nsthreadcurrentthread]);//打印当前线程nslog(@"group---begin");dispatch_group_tgroup=dispatch_group_create();dispatch_group_async(group,dispatch_get_global_queue(dispatch_queue_priority_default,0),^{//追加任务1for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"1---%@",[nsthreadcurrentthread]);//打印当前线程}});dispatch_group_async(group,dispatch_get_global_queue(dispatch_queue_priority_default,0),^{//追加任务2for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"2---%@",[nsthreadcurrentthread]);//打印当前线程}});//等待上面的任务全部完成后，会往下继续执行（会阻塞当前线程）dispatch_group_wait(group,dispatch_time_forever);nslog(@"group---end");}

输出结果：2018-02-2322:10:16.939258+0800ysc-gcd-demo[20538:5198871]currentthread—{number=1,name=main}2018-02-2322:10:16.939455+0800ysc-gcd-demo[20538:5198871]group—begin2018-02-2322:10:18.943862+0800ysc-gcd-demo[20538:5199137]2—{number=4,name=(null)}2018-02-2322:10:18.943861+0800ysc-gcd-demo[20538:5199138]1—{number=3,name=(null)}2018-02-2322:10:20.947787+0800ysc-gcd-demo[20538:5199137]2—{number=4,name=(null)}2018-02-2322:10:20.947790+0800ysc-gcd-demo[20538:5199138]1—{number=3,name=(null)}2018-02-2322:10:20.948134+0800ysc-gcd-demo[20538:5198871]group—end

从dispatch_group_wait相关代码运行输出结果可以看出：当所有任务执行完成之后，才执行dispatch_group_wait之后的操作。但是，使用dispatch_group_wait会阻塞当前线程。

1234567891011121314151617181920212223242526272829303132333435363738394041424344

/***队列组dispatch_group_enter、dispatch_group_leave*/-(void)groupenterandleave{nslog(@"currentthread---%@",[nsthreadcurrentthread]);//打印当前线程nslog(@"group---begin");dispatch_group_tgroup=dispatch_group_create();dispatch_queue_tqueue=dispatch_get_global_queue(dispatch_queue_priority_default,0);dispatch_group_enter(group);dispatch_async(queue,^{//追加任务1for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"1---%@",[nsthreadcurrentthread]);//打印当前线程}dispatch_group_leave(group);});dispatch_group_enter(group);dispatch_async(queue,^{//追加任务2for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"2---%@",[nsthreadcurrentthread]);//打印当前线程}dispatch_group_leave(group);});dispatch_group_notify(group,dispatch_get_main_queue(),^{//等前面的异步操作都执行完毕后，回到主线程.for(inti=0;i<2;++i){[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"3---%@",[nsthreadcurrentthread]);//打印当前线程}nslog(@"group---end");});////等待上面的任务全部完成后，会往下继续执行（会阻塞当前线程）//dispatch_group_wait(group,dispatch_time_forever);////nslog(@"group---end");}

输出结果：2018-02-2322:14:17.997667+0800ysc-gcd-demo[20592:5214830]currentthread—{number=1,name=main}2018-02-2322:14:17.997839+0800ysc-gcd-demo[20592:5214830]group—begin2018-02-2322:14:20.000298+0800ysc-gcd-demo[20592:5215094]1—{number=4,name=(null)}2018-02-2322:14:20.000305+0800ysc-gcd-demo[20592:5215095]2—{number=3,name=(null)}2018-02-2322:14:22.001323+0800ysc-gcd-demo[20592:5215094]1—{number=4,name=(null)}2018-02-2322:14:22.001339+0800ysc-gcd-demo[20592:5215095]2—{number=3,name=(null)}2018-02-2322:14:24.002321+0800ysc-gcd-demo[20592:5214830]3—{number=1,name=main}2018-02-2322:14:26.002852+0800ysc-gcd-demo[20592:5214830]3—{number=1,name=main}2018-02-2322:14:26.003116+0800ysc-gcd-demo[20592:5214830]group—end

从dispatch_group_enter、dispatch_group_leave相关代码运行结果中可以看出：当所有任务执行完成之后，才执行dispatch_group_notify中的任务。这里的dispatch_group_enter、dispatch_group_leave组合，其实等同于dispatch_group_async。

gcd中的信号量是指dispatchsemaphore，是持有计数的信号。类似于过高速路收费站的栏杆。可以通过时，打开栏杆，不可以通过时，关闭栏杆。在dispatchsemaphore中，使用计数来完成这个功能，计数为0时等待，不可通过。计数为1或大于1时，计数减1且不等待，可通过。dispatchsemaphore提供了三个函数。

注意：信号量的使用前提是：想清楚你需要处理哪个线程等待（阻塞），又要哪个线程继续执行，然后使用信号量。

dispatchsemaphore在实际开发中主要用于：

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

123456789101112131415161718192021

-(nsarray*)tasksforkeypath:(nsstring*)keypath{__blocknsarray*tasks=nil;dispatch_semaphore_tsemaphore=dispatch_semaphore_create(0);[self.sessiongettaskswithcompletionhandler:^(nsarray*datatasks,nsarray*uploadtasks,nsarray*downloadtasks){if([keypathisequaltostring:nsstringfromselector(@selector(datatasks))]){tasks=datatasks;}elseif([keypathisequaltostring:nsstringfromselector(@selector(uploadtasks))]){tasks=uploadtasks;}elseif([keypathisequaltostring:nsstringfromselector(@selector(downloadtasks))]){tasks=downloadtasks;}elseif([keypathisequaltostring:nsstringfromselector(@selector(tasks))]){tasks=[@[datatasks,uploadtasks,downloadtasks]valueforkeypath:@"@unionofarrays.self"];}dispatch_semaphore_signal(semaphore);}];dispatch_semaphore_wait(semaphore,dispatch_time_forever);returntasks;}

下面，我们来利用dispatchsemaphore实现线程同步，将异步执行任务转换为同步执行任务。

12345678910111213141516171819202122232425

/***semaphore线程同步*/-(void)semaphoresync{nslog(@"currentthread---%@",[nsthreadcurrentthread]);//打印当前线程nslog(@"semaphore---begin");dispatch_queue_tqueue=dispatch_get_global_queue(dispatch_queue_priority_default,0);dispatch_semaphore_tsemaphore=dispatch_semaphore_create(0);__blockintnumber=0;dispatch_async(queue,^{//追加任务1[nsthreadsleepfortimeinterval:2];//模拟耗时操作nslog(@"1---%@",[nsthreadcurrentthread]);//打印当前线程number=100;dispatch_semaphore_signal(semaphore);});dispatch_semaphore_wait(semaphore,dispatch_time_forever);nslog(@"semaphore---end,number=%zd",number);}

输出结果：2018-02-2322:22:26.521665+0800ysc-gcd-demo[20642:5246341]currentthread—{number=1,name=main}2018-02-2322:22:26.521869+0800ysc-gcd-demo[20642:5246341]semaphore—begin2018-02-2322:22:28.526841+0800ysc-gcd-demo[20642:5246638]1—{number=3,name=(null)}2018-02-2322:22:28.527030+0800ysc-gcd-demo[20642:5246341]semaphore—end,number=100

从dispatchsemaphore实现线程同步的代码可以看到：

线程安全：如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作（更改变量），一般都需要考虑线程同步，否则的话就可能影响线程安全。

线程同步：可理解为线程a和线程b一块配合，a执行到一定程度时要依靠线程b的某个结果，于是停下来，示意b运行；b依言执行，再将结果给a；a再继续操作。

举个简单例子就是：两个人在一起聊天。两个人不能同时说话，避免听不清(操作冲突)。等一个人说完(一个线程结束操作)，另一个再说(另一个线程再开始操作)。

下面，我们模拟火车票售卖的方式，实现nsthread线程安全和解决线程同步问题。

场景：总共有50张火车票，有两个售卖火车票的窗口，一个是北京火车票售卖窗口，另一个是上海火车票售卖窗口。两个窗口同时售卖火车票，卖完为止。

先来看看不考虑线程安全的代码：

123456789101112131415161718192021222324252627282930313233343536373839404142

/***非线程安全：不使用semaphore*初始化火车票数量、卖票窗口(非线程安全)、并开始卖票*/-(void)initticketstatusnotsave{nslog(@"currentthread---%@",[nsthreadcurrentthread]);//打印当前线程nslog(@"semaphore---begin");self.ticketsurpluscount=50;//queue1代表北京火车票售卖窗口dispatch_queue_tqueue1=dispatch_queue_create("net.bujige.testqueue1",dispatch_queue_serial);//queue2代表上海火车票售卖窗口dispatch_queue_tqueue2=dispatch_queue_create("net.bujige.testqueue2",dispatch_queue_serial);__weaktypeof(self)weakself=self;dispatch_async(queue1,^{[weakselfsaleticketnotsafe];});dispatch_async(queue2,^{[weakselfsaleticketnotsafe];});}/***售卖火车票(非线程安全)*/-(void)saleticketnotsafe{while(1){if(self.ticketsurpluscount>0){//如果还有票，继续售卖self.ticketsurpluscount--;nslog(@"%@",[nsstringstringwithformat:@"剩余票数：%d窗口：%@",self.ticketsurpluscount,[nsthreadcurrentthread]]);[nsthreadsleepfortimeinterval:0.2];}else{//如果已卖完，关闭售票窗口nslog(@"所有火车票均已售完");break;}}}

输出结果（部分）：2018-02-2322:25:35.789072+0800ysc-gcd-demo[20712:5258914]currentthread—{number=1,name=main}2018-02-2322:25:35.789260+0800ysc-gcd-demo[20712:5258914]semaphore—begin2018-02-2322:25:35.789641+0800ysc-gcd-demo[20712:5259176]剩余票数：48窗口：{number=3,name=(null)}2018-02-2322:25:35.789646+0800ysc-gcd-demo[20712:5259175]剩余票数：49窗口：{number=4,name=(null)}2018-02-2322:25:35.994113+0800ysc-gcd-demo[20712:5259175]剩余票数：47窗口：{number=4,name=(null)}2018-02-2322:25:35.994129+0800ysc-gcd-demo[20712:5259176]剩余票数：46窗口：{number=3,name=(null)}2018-02-2322:25:36.198993+0800ysc-gcd-demo[20712:5259176]剩余票数：45窗口：{number=3,name=(null)}…

可以看到在不考虑线程安全，不使用semaphore的情况下，得到票数是错乱的，这样显然不符合我们的需求，所以我们需要考虑线程安全问题。

考虑线程安全的代码：

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051

/***线程安全：使用semaphore加锁*初始化火车票数量、卖票窗口(线程安全)、并开始卖票*/-(void)initticketstatussave{nslog(@"currentthread---%@",[nsthreadcurrentthread]);//打印当前线程nslog(@"semaphore---begin");semaphorelock=dispatch_semaphore_create(1);self.ticketsurpluscount=50;//queue1代表北京火车票售卖窗口dispatch_queue_tqueue1=dispatch_queue_create("net.bujige.testqueue1",dispatch_queue_serial);//queue2代表上海火车票售卖窗口dispatch_queue_tqueue2=dispatch_queue_create("net.bujige.testqueue2",dispatch_queue_serial);__weaktypeof(self)weakself=self;dispatch_async(queue1,^{[weakselfsaleticketsafe];});dispatch_async(queue2,^{[weakselfsaleticketsafe];});}/***售卖火车票(线程安全)*/-(void)saleticketsafe{while(1){//相当于加锁dispatch_semaphore_wait(semaphorelock,dispatch_time_forever);if(self.ticketsurpluscount>0){//如果还有票，继续售卖self.ticketsurpluscount--;nslog(@"%@",[nsstringstringwithformat:@"剩余票数：%d窗口：%@",self.ticketsurpluscount,[nsthreadcurrentthread]]);[nsthreadsleepfortimeinterval:0.2];}else{//如果已卖完，关闭售票窗口nslog(@"所有火车票均已售完");//相当于解锁dispatch_semaphore_signal(semaphorelock);break;}//相当于解锁dispatch_semaphore_signal(semaphorelock);}}

输出结果为：2018-02-2322:32:19.814232+0800ysc-gcd-demo[20862:5290531]currentthread—{number=1,name=main}2018-02-2322:32:19.814412+0800ysc-gcd-demo[20862:5290531]semaphore—begin2018-02-2322:32:19.814837+0800ysc-gcd-demo[20862:5290687]剩余票数：49窗口：{number=3,name=(null)}2018-02-2322:32:20.017745+0800ysc-gcd-demo[20862:5290689]剩余票数：48窗口：{number=4,name=(null)}2018-02-2322:32:20.222039+0800ysc-gcd-demo[20862:5290687]剩余票数：47窗口：{number=3,name=(null)}…2018-02-2322:32:29.024817+0800ysc-gcd-demo[20862:5290689]剩余票数：4窗口：{number=4,name=(null)}2018-02-2322:32:29.230110+0800ysc-gcd-demo[20862:5290687]剩余票数：3窗口：{number=3,name=(null)}2018-02-2322:32:29.433615+0800ysc-gcd-demo[20862:5290689]剩余票数：2窗口：{number=4,name=(null)}2018-02-2322:32:29.637572+0800ysc-gcd-demo[20862:5290687]剩余票数：1窗口：{number=3,name=(null)}2018-02-2322:32:29.840234+0800ysc-gcd-demo[20862:5290689]剩余票数：0窗口：{number=4,name=(null)}2018-02-2322:32:30.044960+0800ysc-gcd-demo[20862:5290687]所有火车票均已售完2018-02-2322:32:30.045260+0800ysc-gcd-demo[20862:5290689]所有火车票均已售完

可以看出，在考虑了线程安全的情况下，使用dispatch_semaphore机制之后，得到的票数是正确的，没有出现混乱的情况。我们也就解决了多个线程同步的问题。