iOS多线程全套：线程生命周期，多线程的四种解决方案，线程安全问题，GCD的使用，NSOperation的使用
招聘信息：
目的本文主要是分享iOS多线程的相关内容，为了更系统的讲解，将分为以下7个方面来展开描述。多线程的基本概念线程的状态与生命周期多线程的四种解决方案：pthread，NSThread，GCD，NSOperation线程安全问题NSThread的使用GCD的理解与使用NSOperation的理解与使用Demo在这里：Demo的运行gif图如下：一、多线程的基本概念进程：可以理解成一个运行中的应用程序，是系统进行资源分配和调度的基本单位，是操作系统结构的基础，主要管理资源。线程：是进程的基本执行单元，一个进程对应多个线程。主线程：处理UI，所有更新UI的操作都必须在主线程上执行。不要把耗时操作放在主线程，会卡界面。多线程：在同一时刻，一个CPU只能处理1条线程，但CPU可以在多条线程之间快速的切换，只要切换的足够快，就造成了多线程一同执行的假象。线程就像火车的一节车厢，进程则是火车。车厢（线程）离开火车（进程）是无法跑动的，而火车（进程）至少有一节车厢（主线程）。多线程可以看做多个车厢，它的出现是为了提高效率。多线程是通过提高资源使用率来提高系统总体的效率。我们运用多线程的目的是：将耗时的操作放在后台执行！二、线程的状态与生命周期下图是线程状态示意图，从图中可以看出线程的生命周期是：新建 - 就绪 - 运行 - 阻塞 - 死亡下面分别阐述线程生命周期中的每一步新建：实例化线程对象就绪：向线程对象发送start消息，线程对象被加入可调度线程池等待CPU调度。运行：CPU 负责调度可调度线程池中线程的执行。线程执行完成之前，状态可能会在就绪和运行之间来回切换。就绪和运行之间的状态变化由CPU负责，程序员不能干预。阻塞：当满足某个预定条件时，可以使用休眠或锁，阻塞线程执行。sleepForTimeInterval（休眠指定时长），sleepUntilDate（休眠到指定日期），@synchronized(self)：（互斥锁）。死亡：正常死亡，线程执行完毕。非正常死亡，当满足某个条件后，在线程内部中止执行/在主线程中止线程对象还有线程的exit和cancel[NSThread exit]：一旦强行终止线程，后续的所有代码都不会被执行。[thread cancel]取消：并不会直接取消线程，只是给线程对象添加 isCancelled 标记。三、多线程的四种解决方案多线程的四种解决方案分别是：pthread，NSThread，GCD， NSOperation。下图是对这四种方案进行了解读和对比。四、线程安全问题当多个线程访问同一块资源时，很容易引发数据错乱和数据安全问题。就好比几个人在同一时修改同一个表格，造成数据的错乱。解决多线程安全问题的方法方法一：互斥锁（同步锁）@synchronized(锁对象)&{
&&&&//&需要锁定的代码
}判断的时候锁对象要存在，如果代码中只有一个地方需要加锁，大多都使用self作为锁对象，这样可以避免单独再创建一个锁对象。加了互斥做的代码，当新线程访问时，如果发现其他线程正在执行锁定的代码，新线程就会进入休眠。方法二：自旋锁加了自旋锁，当新线程访问代码时，如果发现有其他线程正在锁定代码，新线程会用死循环的方式，一直等待锁定的代码执行完成。相当于不停尝试执行代码，比较消耗性能。属性修饰atomic本身就有一把自旋锁。下面说一下属性修饰nonatomic 和 atomicnonatomic&非原子属性,同一时间可以有很多线程读和写
atomic&原子属性(线程安全)，保证同一时间只有一个线程能够写入(但是同一个时间多个线程都可以取值)，atomic&本身就有一把锁(自旋锁)
atomic：线程安全，需要消耗大量的资源
nonatomic：非线程安全，不过效率更高，一般使用nonatomic五、NSThread的使用No.1：NSThread创建线程NSThread有三种创建方式：init方式detachNewThreadSelector创建好之后自动启动performSelectorInBackground创建好之后也是直接启动/**&方法一，需要start&*/
NSThread&*thread1&=&[[NSThread&alloc]&initWithTarget:self&selector:@selector(doSomething1:)&object:@"NSThread1"];
//&线程加入线程池等待CPU调度，时间很快，几乎是立刻执行
[thread1&start];
/**&方法二，创建好之后自动启动&*/
[NSThread&detachNewThreadSelector:@selector(doSomething2:)&toTarget:self&withObject:@"NSThread2"];
/**&方法三，隐式创建，直接启动&*/
[self&performSelectorInBackground:@selector(doSomething3:)&withObject:@"NSThread3"];
-&(void)doSomething1:(NSObject&*)object&{
&&&&//&传递过来的参数
&&&&NSLog(@"%@",object);
&&&&NSLog(@"doSomething1：%@",[NSThread&currentThread]);
-&(void)doSomething2:(NSObject&*)object&{
&&&&NSLog(@"%@",object);
&&&&NSLog(@"doSomething2：%@",[NSThread&currentThread]);
-&(void)doSomething3:(NSObject&*)object&{
&&&&NSLog(@"%@",object);
&&&&NSLog(@"doSomething3：%@",[NSThread&currentThread]);
}No.2：NSThread的类方法返回当前线程//&当前线程
[NSThread&currentThread];
NSLog(@"%@",[NSThread&currentThread]);
//&如果number=1，则表示在主线程，否则是子线程
打印结果：{number&=&1,&name&=&main}阻塞休眠//休眠多久
[NSThread&sleepForTimeInterval:2];
//休眠到指定时间
[NSThread&sleepUntilDate:[NSDate&date]];类方法补充//退出线程
[NSThread&exit];
//判断当前线程是否为主线程
[NSThread&isMainThread];
//判断当前线程是否是多线程
[NSThread&isMultiThreaded];
//主线程的对象
NSThread&*mainThread&=&[NSThread&mainThread];No.3：NSThread的一些属性//线程是否在执行
thread.isE
//线程是否被取消
thread.isC
//线程是否完成
thread.isF
//是否是主线程
thread.isMainT
//线程的优先级，取值范围0.0到1.0，默认优先级0.5，1.0表示最高优先级，优先级高，CPU调度的频率高
&thread.threadPDemo：六、GCD的理解与使用No.1：GCD的特点GCD会自动利用更多的CPU内核GCD自动管理线程的生命周期（创建线程，调度任务，销毁线程等）程序员只需要告诉 GCD 想要如何执行什么任务，不需要编写任何线程管理代码No.2：GCD的基本概念任务（block）：任务就是将要在线程中执行的代码，将这段代码用block封装好，然后将这个任务添加到指定的执行方式（同步执行和异步执行），等待CPU从队列中取出任务放到对应的线程中执行。同步（sync）：一个接着一个，前一个没有执行完，后面不能执行，不开线程。异步（async）：开启多个新线程，任务同一时间可以一起执行。异步是多线程的代名词队列：装载线程任务的队形结构。(系统以先进先出的方式调度队列中的任务执行)。在GCD中有两种队列：串行队列和并发队列。并发队列：线程可以同时一起进行执行。实际上是CPU在多条线程之间快速的切换。（并发功能只有在异步（dispatch_async）函数下才有效）串行队列：线程只能依次有序的执行。GCD总结：将任务(要在线程中执行的操作block)添加到队列(自己创建或使用全局并发队列)，并且指定执行任务的方式(异步dispatch_async，同步dispatch_sync)No.3：队列的创建方法使用dispatch_queue_create来创建队列对象，传入两个参数，第一个参数表示队列的唯一标识符，可为空。第二个参数用来表示串行队列（DISPATCH_QUEUE_SERIAL）或并发队列（DISPATCH_QUEUE_CONCURRENT）。//&串行队列
dispatch_queue_t&queue&=&dispatch_queue_create("test",&DISPATCH_QUEUE_SERIAL);
//&并发队列
dispatch_queue_t&queue1&=&dispatch_queue_create("test",&DISPATCH_QUEUE_CONCURRENT);GCD的队列还有另外两种：主队列：主队列负责在主线程上调度任务，如果在主线程上已经有任务正在执行，主队列会等到主线程空闲后再调度任务。通常是返回主线程更新UI的时候使用。dispatch_get_main_queue()&&dispatch_async(dispatch_get_global_queue(0,&0),&^{
&&&&&&//&耗时操作放在这里
&&&&&&dispatch_async(dispatch_get_main_queue(),&^{
&&&&&&&&&&//&回到主线程进行UI操作
&&});全局并发队列：全局并发队列是就是一个并发队列，是为了让我们更方便的使用多线程。dispatch_get_global_queue(0, 0)//全局并发队列
dispatch_queue_t&queue&=&dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,&0);
//全局并发队列的优先级
#define&DISPATCH_QUEUE_PRIORITY_HIGH&2&//&高优先级
#define&DISPATCH_QUEUE_PRIORITY_DEFAULT&0&//&默认（中）优先级
#define&DISPATCH_QUEUE_PRIORITY_LOW&(-2)&//&低优先级
#define&DISPATCH_QUEUE_PRIORITY_BACKGROUND&INT16_MIN&//&后台优先级
//iOS8开始使用服务质量，现在获取全局并发队列时，可以直接传0
dispatch_get_global_queue(0,&0);No.4：同步/异步/任务、创建方式同步（sync）使用dispatch_sync来表示。异步（async）使用dispatch_async。任务就是将要在线程中执行的代码，将这段代码用block封装好。代码如下：&&&&//&同步执行任务
&&&&dispatch_sync(dispatch_get_global_queue(0,&0),&^{
&&&&&&&&//&任务放在这个block里
&&&&&&&&NSLog(@"我是同步执行的任务");
&&&&//&异步执行任务
&&&&dispatch_async(dispatch_get_global_queue(0,&0),&^{
&&&&&&&&//&任务放在这个block里
&&&&&&&&NSLog(@"我是异步执行的任务");
&&&&});Demo：No.5：GCD的使用由于有多种队列（串行/并发/主队列）和两种执行方式（同步/异步），所以他们之间可以有多种组合方式。串行同步串行异步并发同步并发异步主队列同步主队列异步串行同步执行完一个任务，再执行下一个任务。不开启新线程。/**&串行同步&*/
-&(void)syncSerial&{
&&&&NSLog(@"\n\n**************串行同步***************\n\n");
&&&&//&串行队列
&&&&dispatch_queue_t&queue&=&dispatch_queue_create("test",&DISPATCH_QUEUE_SERIAL);
&&&&//&同步执行
&&&&dispatch_sync(queue,&^{
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"串行同步1&&&%@",[NSThread&currentThread]);
&&&&dispatch_sync(queue,&^{
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"串行同步2&&&%@",[NSThread&currentThread]);
&&&&dispatch_sync(queue,&^{
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"串行同步3&&&%@",[NSThread&currentThread]);
}输入结果为顺序执行，都在主线程：串行同步1&&&{number&=&1,&name&=&main}
串行同步1&&&{number&=&1,&name&=&main}
串行同步1&&&{number&=&1,&name&=&main}
串行同步2&&&{number&=&1,&name&=&main}
串行同步2&&&{number&=&1,&name&=&main}
串行同步2&&&{number&=&1,&name&=&main}
串行同步3&&&{number&=&1,&name&=&main}
串行同步3&&&{number&=&1,&name&=&main}
串行同步3&&&{number&=&1,&name&=&main}串行异步开启新线程，但因为任务是串行的，所以还是按顺序执行任务。/**&串行异步&*/
-&(void)asyncSerial&{
&&&&NSLog(@"\n\n**************串行异步***************\n\n");
&&&&//&串行队列
&&&&dispatch_queue_t&queue&=&dispatch_queue_create("test",&DISPATCH_QUEUE_SERIAL);
&&&&//&同步执行
&&&&dispatch_async(queue,&^{
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"串行异步1&&&%@",[NSThread&currentThread]);
&&&&dispatch_async(queue,&^{
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"串行异步2&&&%@",[NSThread&currentThread]);
&&&&dispatch_async(queue,&^{
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"串行异步3&&&%@",[NSThread&currentThread]);
}输入结果为顺序执行，有不同线程：串行异步1&&&{number&=&3,&name&=&(null)}
串行异步1&&&{number&=&3,&name&=&(null)}
串行异步1&&&{number&=&3,&name&=&(null)}
串行异步2&&&{number&=&3,&name&=&(null)}
串行异步2&&&{number&=&3,&name&=&(null)}
串行异步2&&&{number&=&3,&name&=&(null)}
串行异步3&&&{number&=&3,&name&=&(null)}
串行异步3&&&{number&=&3,&name&=&(null)}
串行异步3&&&{number&=&3,&name&=&(null)}并发同步因为是同步的，所以执行完一个任务，再执行下一个任务。不会开启新线程。/**&并发同步&*/
-&(void)syncConcurrent&{
&&&&NSLog(@"\n\n**************并发同步***************\n\n");
&&&&//&并发队列
&&&&dispatch_queue_t&queue&=&dispatch_queue_create("test",&DISPATCH_QUEUE_CONCURRENT);
&&&&//&同步执行
&&&&dispatch_sync(queue,&^{
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"并发同步1&&&%@",[NSThread&currentThread]);
&&&&dispatch_sync(queue,&^{
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"并发同步2&&&%@",[NSThread&currentThread]);
&&&&dispatch_sync(queue,&^{
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"并发同步3&&&%@",[NSThread&currentThread]);
}输入结果为顺序执行，都在主线程：并发同步1&&&{number&=&1,&name&=&main}
并发同步1&&&{number&=&1,&name&=&main}
并发同步1&&&{number&=&1,&name&=&main}
并发同步2&&&{number&=&1,&name&=&main}
并发同步2&&&{number&=&1,&name&=&main}
并发同步2&&&{number&=&1,&name&=&main}
并发同步3&&&{number&=&1,&name&=&main}
并发同步3&&&{number&=&1,&name&=&main}
并发同步3&&&{number&=&1,&name&=&main}并发异步任务交替执行，开启多线程。/**&并发异步&*/
-&(void)asyncConcurrent&{
&&&&NSLog(@"\n\n**************并发异步***************\n\n");
&&&&//&并发队列
&&&&dispatch_queue_t&queue&=&dispatch_queue_create("test",&DISPATCH_QUEUE_CONCURRENT);
&&&&//&同步执行
&&&&dispatch_async(queue,&^{
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"并发异步1&&&%@",[NSThread&currentThread]);
&&&&dispatch_async(queue,&^{
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"并发异步2&&&%@",[NSThread&currentThread]);
&&&&dispatch_async(queue,&^{
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"并发异步3&&&%@",[NSThread&currentThread]);
}输入结果为无序执行，有多条线程：并发异步1&&&{number&=&3,&name&=&(null)}
并发异步2&&&{number&=&4,&name&=&(null)}
并发异步3&&&{number&=&5,&name&=&(null)}
并发异步1&&&{number&=&3,&name&=&(null)}
并发异步2&&&{number&=&4,&name&=&(null)}
并发异步3&&&{number&=&5,&name&=&(null)}
并发异步1&&&{number&=&3,&name&=&(null)}
并发异步2&&&{number&=&4,&name&=&(null)}
并发异步3&&&{number&=&5,&name&=&(null)}主队列同步如果在主线程中运用这种方式，则会发生死锁，程序崩溃。/**&主队列同步&*/
-&(void)syncMain&{
&&&&NSLog(@"\n\n**************主队列同步，放到主线程会死锁***************\n\n");
&&&&//&主队列
&&&&dispatch_queue_t&queue&=&dispatch_get_main_queue();
&&&&dispatch_sync(queue,&^{
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"主队列同步1&&&%@",[NSThread&currentThread]);
&&&&dispatch_sync(queue,&^{
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"主队列同步2&&&%@",[NSThread&currentThread]);
&&&&dispatch_sync(queue,&^{
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"主队列同步3&&&%@",[NSThread&currentThread]);
}主队列同步造成死锁的原因：如果在主线程中运用主队列同步，也就是把任务放到了主线程的队列中。而同步对于任务是立刻执行的，那么当把第一个任务放进主队列时，它就会立马执行。可是主线程现在正在处理syncMain方法，任务需要等syncMain执行完才能执行。syncMain执行到第一个任务的时候，又要等第一个任务执行完才能往下执行第二个和第三个任务。这样syncMain方法和第一个任务就开始了互相等待，形成了死锁。主队列异步在主线程中任务按顺序执行。/**&主队列异步&*/
-&(void)asyncMain&{
&&&&NSLog(@"\n\n**************主队列异步***************\n\n");
&&&&//&主队列
&&&&dispatch_queue_t&queue&=&dispatch_get_main_queue();
&&&&dispatch_sync(queue,&^{
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"主队列异步1&&&%@",[NSThread&currentThread]);
&&&&dispatch_sync(queue,&^{
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"主队列异步2&&&%@",[NSThread&currentThread]);
&&&&dispatch_sync(queue,&^{
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"主队列异步3&&&%@",[NSThread&currentThread]);
}输入结果为在主线程中按顺序执行：主队列异步1&&&{number&=&1,&name&=&main}
主队列异步1&&&{number&=&1,&name&=&main}
主队列异步1&&&{number&=&1,&name&=&main}
主队列异步2&&&{number&=&1,&name&=&main}
主队列异步2&&&{number&=&1,&name&=&main}
主队列异步2&&&{number&=&1,&name&=&main}
主队列异步3&&&{number&=&1,&name&=&main}
主队列异步3&&&{number&=&1,&name&=&main}
主队列异步3&&&{number&=&1,&name&=&main}GCD线程之间的通讯开发中需要在主线程上进行UI的相关操作，通常会把一些耗时的操作放在其他线程，比如说图片文件下载等耗时操作。当完成了耗时操作之后，需要回到主线程进行UI的处理，这里就用到了线程之间的通讯。-&(IBAction)communicationBetweenThread:(id)sender&{
&&&&//&异步
&&&&dispatch_async(dispatch_get_global_queue(0,&0),&^{
&&&&&&&&//&耗时操作放在这里，例如下载图片。（运用线程休眠两秒来模拟耗时操作）
&&&&&&&&[NSThread&sleepForTimeInterval:2];
&&&&&&&&NSString&*picURLStr&=&@"http://www.bangmangxuan.net/uploads/allimg/-.jpg";
&&&&&&&&NSURL&*picURL&=&[NSURL&URLWithString:picURLStr];
&&&&&&&&NSData&*picData&=&[NSData&dataWithContentsOfURL:picURL];
&&&&&&&&UIImage&*image&=&[UIImage&imageWithData:picData];
&&&&&&&&//&回到主线程处理UI
&&&&&&&&dispatch_async(dispatch_get_main_queue(),&^{
&&&&&&&&&&&&//&在主线程上添加图片
&&&&&&&&&&&&self.imageView.image&=&
&&&&&&&&});
}上面的代码是在新开的线程中进行图片的下载，下载完成之后回到主线程显示图片。GCD栅栏当任务需要异步进行，但是这些任务需要分成两组来执行，第一组完成之后才能进行第二组的操作。这时候就用了到GCD的栅栏方法dispatch_barrier_async。-&(IBAction)barrierGCD:(id)sender&{
&&&&//&并发队列
&&&&dispatch_queue_t&queue&=&dispatch_queue_create("test",&DISPATCH_QUEUE_CONCURRENT);
&&&&//&异步执行
&&&&dispatch_async(queue,&^{
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"栅栏：并发异步1&&&%@",[NSThread&currentThread]);
&&&&dispatch_async(queue,&^{
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"栅栏：并发异步2&&&%@",[NSThread&currentThread]);
&&&&dispatch_barrier_async(queue,&^{
&&&&&&&&NSLog(@"------------barrier------------%@",&[NSThread&currentThread]);
&&&&&&&&NSLog(@"*******&并发异步执行，但是34一定在12后面&*********");
&&&&dispatch_async(queue,&^{
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"栅栏：并发异步3&&&%@",[NSThread&currentThread]);
&&&&dispatch_async(queue,&^{
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"栅栏：并发异步4&&&%@",[NSThread&currentThread]);
}上面代码的打印结果如下，开启了多条线程，所有任务都是并发异步进行。但是第一组完成之后，才会进行第二组的操作。栅栏：并发异步1&&&{number&=&3,&name&=&(null)}
栅栏：并发异步2&&&{number&=&6,&name&=&(null)}
栅栏：并发异步1&&&{number&=&3,&name&=&(null)}
栅栏：并发异步2&&&{number&=&6,&name&=&(null)}
栅栏：并发异步1&&&{number&=&3,&name&=&(null)}
栅栏：并发异步2&&&{number&=&6,&name&=&(null)}
&------------barrier------------{number&=&6,&name&=&(null)}
*******&并发异步执行，但是34一定在12后面&*********
栅栏：并发异步4&&&{number&=&3,&name&=&(null)}
栅栏：并发异步3&&&{number&=&6,&name&=&(null)}
栅栏：并发异步4&&&{number&=&3,&name&=&(null)}
栅栏：并发异步3&&&{number&=&6,&name&=&(null)}
栅栏：并发异步4&&&{number&=&3,&name&=&(null)}
栅栏：并发异步3&&&{number&=&6,&name&=&(null)}GCD延时执行当需要等待一会再执行一段代码时，就可以用到这个方法了：dispatch_after。dispatch_after(dispatch_time(DISPATCH_TIME_NOW,&(int64_t)(5.0&*&NSEC_PER_SEC)),&dispatch_get_main_queue(),&^{
&&&&//&5秒后异步执行
&&&&NSLog(@"我已经等待了5秒！");
GCD实现代码只执行一次
使用dispatch_once能保证某段代码在程序运行过程中只被执行1次。可以用来设计单例。
static&dispatch_once_t&onceT
dispatch_once(&onceToken,&^{
&&&&NSLog(@"程序运行过程中我只执行了一次！");
});GCD快速迭代GCD有一个快速迭代的方法dispatch_apply，dispatch_apply可以同时遍历多个数字。-&(IBAction)applyGCD:(id)sender&{
&&&&NSLog(@"\n\n**************&GCD快速迭代&***************\n\n");
&&&&//&并发队列
&&&&dispatch_queue_t&queue&=&dispatch_get_global_queue(0,&0);
&&&&//&dispatch_apply几乎同时遍历多个数字
&&&&dispatch_apply(7,&queue,&^(size_t&index)&{
&&&&&&&&NSLog(@"dispatch_apply：%zd======%@",index,&[NSThread&currentThread]);
}打印结果如下：dispatch_apply：0======{number&=&1,&name&=&main}
dispatch_apply：1======{number&=&1,&name&=&main}
dispatch_apply：2======{number&=&1,&name&=&main}
dispatch_apply：3======{number&=&1,&name&=&main}
dispatch_apply：4======{number&=&1,&name&=&main}
dispatch_apply：5======{number&=&1,&name&=&main}
dispatch_apply：6======{number&=&1,&name&=&main}GCD队列组异步执行几个耗时操作，当这几个操作都完成之后再回到主线程进行操作，就可以用到队列组了。队列组有下面几个特点：所有的任务会并发的执行(不按序)。所有的异步函数都添加到队列中，然后再纳入队列组的监听范围。使用dispatch_group_notify函数，来监听上面的任务是否完成，如果完成, 就会调用这个方法。队列组示例代码：-&(void)testGroup&{
&&&&dispatch_group_t&group&=&&dispatch_group_create();
&&&&dispatch_group_async(group,&dispatch_get_global_queue(0,&0),&^{
&&&&&&&&NSLog(@"队列组：有一个耗时操作完成！");
&&&&dispatch_group_async(group,&dispatch_get_global_queue(0,&0),&^{
&&&&&&&&NSLog(@"队列组：有一个耗时操作完成！");
&&&&dispatch_group_notify(group,&dispatch_get_main_queue(),&^{
&&&&&&&&NSLog(@"队列组：前面的耗时操作都完成了，回到主线程进行相关操作");
}打印结果如下：队列组：有一个耗时操作完成！
队列组：有一个耗时操作完成！
队列组：前面的耗时操作都完成了，回到主线程进行相关操作至此，GCD的相关内容叙述完毕。下面让我们继续学习NSOperation。Demo：七、NSOperation的理解与使用No.1：NSOperation简介NSOperation是基于GCD之上的更高一层封装，NSOperation需要配合NSOperationQueue来实现多线程。NSOperation实现多线程的步骤如下：1.&创建任务：先将需要执行的操作封装到NSOperation对象中。
2.&创建队列：创建NSOperationQueue。
3.&将任务加入到队列中：将NSOperation对象添加到NSOperationQueue中。需要注意的是，NSOperation是个抽象类，实际运用时中需要使用它的子类，有三种方式：使用子类NSInvocationOperation使用子类NSBlockOperation定义继承自NSOperation的子类，通过实现内部相应的方法来封装任务。No.2：NSOperation的三种创建方式NSInvocationOperation的使用创建NSInvocationOperation对象并关联方法，之后start。-&(void)testNSInvocationOperation&{
&&&&//&创建NSInvocationOperation
&&&&NSInvocationOperation&*invocationOperation&=&[[NSInvocationOperation&alloc]&initWithTarget:self&selector:@selector(invocationOperation)&object:nil];
&&&&//&开始执行操作
&&&&[invocationOperation&start];
-&(void)invocationOperation&{
&&&&NSLog(@"NSInvocationOperation包含的任务，没有加入队列========%@",&[NSThread&currentThread]);
}打印结果如下，得到结论：程序在主线程执行，没有开启新线程。这是因为NSOperation多线程的使用需要配合队列NSOperationQueue，后面会讲到NSOperationQueue的使用。NSInvocationOperation包含的任务，没有加入队列========{number&=&1,&name&=&main}NSBlockOperation的使用把任务放到NSBlockOperation的block中，然后start。-&(void)testNSBlockOperation&{
&&&&//&把任务放到block中
&&&&NSBlockOperation&*blockOperation&=&[NSBlockOperation&blockOperationWithBlock:^{
&&&&&&&&NSLog(@"NSBlockOperation包含的任务，没有加入队列========%@",&[NSThread&currentThread]);
&&&&[blockOperation&start];
}执行结果如下，可以看出：主线程执行，没有开启新线程。同样的，NSBlockOperation可以配合队列NSOperationQueue来实现多线程。NSBlockOperation包含的任务，没有加入队列========{number&=&1,&name&=&main}但是NSBlockOperation有一个方法addExecutionBlock:，通过这个方法可以让NSBlockOperation实现多线程。-&(void)testNSBlockOperationExecution&{
&&&&NSBlockOperation&*blockOperation&=&[NSBlockOperation&blockOperationWithBlock:^{
&&&&&&&&NSLog(@"NSBlockOperation运用addExecutionBlock主任务========%@",&[NSThread&currentThread]);
&&&&[blockOperation&addExecutionBlock:^{
&&&&&&&&NSLog(@"NSBlockOperation运用addExecutionBlock方法添加任务1========%@",&[NSThread&currentThread]);
&&&&[blockOperation&addExecutionBlock:^{
&&&&&&&&NSLog(@"NSBlockOperation运用addExecutionBlock方法添加任务2========%@",&[NSThread&currentThread]);
&&&&[blockOperation&addExecutionBlock:^{
&&&&&&&&NSLog(@"NSBlockOperation运用addExecutionBlock方法添加任务3========%@",&[NSThread&currentThread]);
&&&&[blockOperation&start];
}执行结果如下，可以看出，NSBlockOperation创建时block中的任务是在主线程执行，而运用addExecutionBlock加入的任务是在子线程执行的。NSBlockOperation运用addExecutionBlock========{number&=&1,&name&=&main}
addExecutionBlock方法添加任务1========{number&=&3,&name&=&(null)}
addExecutionBlock方法添加任务3========{number&=&5,&name&=&(null)}
addExecutionBlock方法添加任务2========{number&=&4,&name&=&(null)}运用继承自NSOperation的子类首先我们定义一个继承自NSOperation的类，然后重写它的main方法，之后就可以使用这个子类来进行相关的操作了。/*******************"WHOperation.h"*************************/
#import&@interface&WHOperation&:&NSOperation
/*******************"WHOperation.m"*************************/
#import&"WHOperation.h"
@implementation&WHOperation
-&(void)main&{
&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&NSLog(@"NSOperation的子类WHOperation======%@",[NSThread&currentThread]);
/*****************回到主控制器使用WHOperation**********************/
-&(void)testWHOperation&{
&&&&WHOperation&*operation&=&[[WHOperation&alloc]&init];
&&&&[operation&start];
}运行结果如下，依然是在主线程执行。SOperation的子类WHOperation======{number&=&1,&name&=&main}
NSOperation的子类WHOperation======{number&=&1,&name&=&main}
NSOperation的子类WHOperation======{number&=&1,&name&=&main}所以，NSOperation是需要配合队列NSOperationQueue来实现多线程的。下面就来说一下队列NSOperationQueue。No.3：队列NSOperationQueueNSOperationQueue只有两种队列：主队列、其他队列。其他队列包含了串行和并发。主队列的创建如下，主队列上的任务是在主线程执行的。NSOperationQueue&*mainQueue&=&[NSOperationQueue&mainQueue];其他队列（非主队列）的创建如下，加入到‘非队列’中的任务默认就是并发，开启多线程。NSOperationQueue&*queue&=&[[NSOperationQueue&alloc]&init];注意：非主队列（其他队列）可以实现串行或并行。队列NSOperationQueue有一个参数叫做最大并发数：maxConcurrentOperationCount。maxConcurrentOperationCount默认为-1，直接并发执行，所以加入到‘非队列’中的任务默认就是并发，开启多线程。当maxConcurrentOperationCount为1时，则表示不开线程，也就是串行。当maxConcurrentOperationCount大于1时，进行并发执行。系统对最大并发数有一个限制，所以即使程序员把maxConcurrentOperationCount设置的很大，系统也会自动调整。所以把最大并发数设置的很大是没有意义的。No.4：NSOperation + NSOperationQueue把任务加入队列，这才是NSOperation的常规使用方式。addOperation添加任务到队列先创建好任务，然后运用- (void)addOperation:(NSOperation *)op 方法来吧任务添加到队列中，示例代码如下：-&(void)testOperationQueue&{
&&&&//&创建队列，默认并发
&&&&NSOperationQueue&*queue&=&[[NSOperationQueue&alloc]&init];
&&&&//&创建操作，NSInvocationOperation
&&&&NSInvocationOperation&*invocationOperation&=&[[NSInvocationOperation&alloc]&initWithTarget:self&selector:@selector(invocationOperationAddOperation)&object:nil];
&&&&//&创建操作，NSBlockOperation
&&&&NSBlockOperation&*blockOperation&=&[NSBlockOperation&blockOperationWithBlock:^{
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"addOperation把任务添加到队列======%@",&[NSThread&currentThread]);
&&&&[queue&addOperation:invocationOperation];
&&&&[queue&addOperation:blockOperation];
-&(void)invocationOperationAddOperation&{
&&&&NSLog(@"invocationOperation===aaddOperation把任务添加到队列====%@",&[NSThread&currentThread]);
}运行结果如下，可以看出，任务都是在子线程执行的，开启了新线程！invocationOperation===addOperation把任务添加到队列===={number&=&4,&name&=&(null)}
addOperation把任务添加到队列======{number&=&3,&name&=&(null)}
addOperation把任务添加到队列======{number&=&3,&name&=&(null)}
addOperation把任务添加到队列======{number&=&3,&name&=&(null)}addOperationWithBlock添加任务到队列这是一个更方便的把任务添加到队列的方法，直接把任务写在block中，添加到任务中。-&(void)testAddOperationWithBlock&{
&&&&//&创建队列，默认并发
&&&&NSOperationQueue&*queue&=&[[NSOperationQueue&alloc]&init];
&&&&//&添加操作到队列
&&&&[queue&addOperationWithBlock:^{
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"addOperationWithBlock把任务添加到队列======%@",&[NSThread&currentThread]);
}运行结果如下，任务确实是在子线程中执行。addOperationWithBlock把任务添加到队列======{number&=&3,&name&=&(null)}
addOperationWithBlock把任务添加到队列======{number&=&3,&name&=&(null)}
addOperationWithBlock把任务添加到队列======{number&=&3,&name&=&(null)}运用最大并发数实现串行上面已经说过，可以运用队列的属性maxConcurrentOperationCount（最大并发数）来实现串行，值需要把它设置为1就可以了，下面我们通过代码验证一下。-&(void)testMaxConcurrentOperationCount&{
&&&&//&创建队列，默认并发
&&&&NSOperationQueue&*queue&=&[[NSOperationQueue&alloc]&init];
&&&&//&最大并发数为1，串行
&&&&queue.maxConcurrentOperationCount&=&1;
&&&&//&最大并发数为2，并发
//&&&&queue.maxConcurrentOperationCount&=&2;
&&&&//&添加操作到队列
&&&&[queue&addOperationWithBlock:^{
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"addOperationWithBlock把任务添加到队列1======%@",&[NSThread&currentThread]);
&&&&//&添加操作到队列
&&&&[queue&addOperationWithBlock:^{
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"addOperationWithBlock把任务添加到队列2======%@",&[NSThread&currentThread]);
&&&&//&添加操作到队列
&&&&[queue&addOperationWithBlock:^{
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"addOperationWithBlock把任务添加到队列3======%@",&[NSThread&currentThread]);
}运行结果如下，当最大并发数为1的时候，虽然开启了线程，但是任务是顺序执行的，所以实现了串行。你可以尝试把上面的最大并发数变为2，会发现任务就变成了并发执行。addOperationWithBlock把任务添加到队列1======{number&=&3,&name&=&(null)}
addOperationWithBlock把任务添加到队列1======{number&=&3,&name&=&(null)}
addOperationWithBlock把任务添加到队列1======{number&=&3,&name&=&(null)}
addOperationWithBlock把任务添加到队列2======{number&=&3,&name&=&(null)}
addOperationWithBlock把任务添加到队列2======{number&=&3,&name&=&(null)}
addOperationWithBlock把任务添加到队列2======{number&=&3,&name&=&(null)}
addOperationWithBlock把任务添加到队列3======{number&=&3,&name&=&(null)}
addOperationWithBlock把任务添加到队列3======{number&=&3,&name&=&(null)}
addOperationWithBlock把任务添加到队列3======{number&=&3,&name&=&(null)}No.5：NSOperation的其他操作取消队列NSOperationQueue的所有操作，NSOperationQueue对象方法-&(void)cancelAllOperations取消NSOperation的某个操作，NSOperation对象方法-&(void)cancel使队列暂停或继续//&暂停队列
[queue&setSuspended:YES];判断队列是否暂停-&(BOOL)isSuspended暂停和取消不是立刻取消当前操作，而是等当前的操作执行完之后不再进行新的操作。No.6：NSOperation的操作依赖NSOperation有一个非常好用的方法，就是操作依赖。可以从字面意思理解：某一个操作（operation2）依赖于另一个操作（operation1），只有当operation1执行完毕，才能执行operation2，这时，就是操作依赖大显身手的时候了。-&(void)testAddDependency&{
&&&&//&并发队列
&&&&NSOperationQueue&*queue&=&[[NSOperationQueue&alloc]&init];
&&&&//&操作1
&&&&NSBlockOperation&*operation1&=&[NSBlockOperation&blockOperationWithBlock:^{
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"operation1======%@",&[NSThread&&currentThread]);
&&&&//&操作2
&&&&NSBlockOperation&*operation2&=&[NSBlockOperation&blockOperationWithBlock:^{
&&&&&&&&NSLog(@"****operation2依赖于operation1，只有当operation1执行完毕，operation2才会执行****");
&&&&&&&&for&(int&i&=&0;&i&<&3;&i++)&{
&&&&&&&&&&&&NSLog(@"operation2======%@",&[NSThread&&currentThread]);
&&&&//&使操作2依赖于操作1
&&&&[operation2&addDependency:operation1];
&&&&//&把操作加入队列
&&&&[queue&addOperation:operation1];
&&&&[queue&addOperation:operation2];
}运行结果如下，操作2总是在操作1之后执行，成功验证了上面的说法。operation1======{number&=&3,&name&=&(null)}
operation1======{number&=&3,&name&=&(null)}
operation1======{number&=&3,&name&=&(null)}
****operation2依赖于operation1，只有当operation1执行完毕，operation2才会执行****
operation2======{number&=&4,&name&=&(null)}
operation2======{number&=&4,&name&=&(null)}
operation2======{number&=&4,&name&=&(null)}后记本文所述的示例代码在这里：推荐简单又好用的分类集合：github地址：
微信扫一扫
订阅每日移动开发及APP推广热点资讯公众号：CocoaChina
您还没有登录！请或
点击量4799点击量4152点击量3779点击量3431点击量3162点击量3159点击量3130点击量2968点击量2854
&2016 Chukong Technologies,Inc.
京公网安备89