在iOS开发中，我们经常会使用到多线程技术，用于处理一些比较耗时的操作。在iOS中，有四种多线程的API，接下来我会带领大家一起去了解一下多线程相关的知识，以便帮助大家更好的使用多线程编程。下面先看一下四种API的比较：
iOS中常见的多线程方案
pthread：基于C语言，可以跨平台使用，需要程序员管理生命周期，使用难度大，所以不怎么使用
NSThread：基于OC，面向对象，操作简单，需要程序员管理生命周期，使用较少
GCD：基于C语言，充分利用设备的多核，自动管理生命周期，使用频繁
NSOperation：基于OC，对GCD的封装，面向对象，使用简单，使用频繁
在这里，我们详细介绍下线程的使用方法：
NSThread
NSThread有三种创建方式：
- init方式
- detachNewThreadSelector创建好之后自动启动
- performSelectorInBackground创建好之后也是直接启动
/** 方法一，需要start */
NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(doSomething1:) object:@"NSThread"];
// 线程加入线程池等待CPU调度，时间很快，几乎是立刻执行
[thread1 start];
/** 方法二，创建好之后自动启动 */
[NSThread detachNewThreadSelector:@selector(doSomething) toTarget:self withObject:@"NSThread"];
/** 方法三，隐式创建，直接启动 */
[self performSelectorInBackground:@selector(doSomething) withObject:@"NSThread"];
还有一些线程相关的属性和方法，不完全，大家可以到API自己查看：
//线程是否在执行
thread.isExecuting;
//线程是否被取消
thread.isCancelled;
//线程是否完成
thread.isFinished;
//是否是主线程
thread.isMainThread;
//线程的优先级，取值范围0.0到1.0，默认优先级0.5，1.0表示最高优先级，优先级高，CPU调度的频率高
thread.threadPriority;
// 当前线程
[NSThread currentThread];
//休眠多久
[NSThread sleepForTimeInterval:2];
//休眠到指定时间
[NSThread sleepUntilDate:[NSDate date]];
//退出线程
[NSThread exit];
//判断当前线程是否为主线程
[NSThread isMainThread];
//判断当前线程是否是多线程
[NSThread isMultiThreaded];
//主线程的对象
NSThread *mainThread = [NSThread mainThread];
GCD
GCD的基本概念:任务和队列
任务:
- 同步：一个接着一个，前一个没有执行完，后面不能执行，不开线程。
- 异步：开启多个新线程，任务同一时间可以一起执行。异步是多线程的代名词
队列：
- 并发队列：线程可以同时一起进行执行。实际上是CPU在多条线程之间快速的切换。（并发功能只有在异步（dispatch_async）函数下才有效）
- 串行队列：线程只能依次有序的执行。
队列的创建方法
使用dispatch_queue_create来创建队列对象，传入两个参数，第一个参数表示队列的唯一标识符，可为空。第二个参数用来表示串行队列或并发队列
// 串行队列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
// 并发队列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
GCD的队列还有另外两种：
主队列：主队列负责在主线程上调度任务，如果在主线程上已经有任务正在执行，主队列会等到主线程空闲后再调度任务。通常是返回主线程更新UI的时候使用。dispatch_get_main_queue()
全局并发队列：全局并发队列是就是一个并发队列，是为了让我们更方便的使用多线程。dispatch_get_global_queue(0, 0)
同步/异步/任务创建方式
同步（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(@"我是异步执行的任务");
});
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]);
}
});
}
/** 串行异步 */
- (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]);
}
});
}
/** 并发同步 */
- (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]);
}
});
}
/** 并发异步 */
- (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]);
}
});
}
/** 主队列同步 */
- (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]);
}
});
}
GCD线程之间的通讯
开发中需要在主线程上进行UI的相关操作，通常会把一些耗时的操作放在其他线程，比如说图片文件下载等耗时操作。当完成了耗时操作之后，需要回到主线程进行UI的处理，这里就用到了线程之间的通讯。
// 异步
dispatch_async(dispatch_get_global_queue(0, 0), ^{
// 耗时操作放在这里，例如下载图片。（运用线程休眠两秒来模拟耗时操作）
[NSThread sleepForTimeInterval:2];
NSString *picURLStr = @"http://www.bangmangxuan.net/uploads/allimg/160320/74-160320130500.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 = image;
});
});
GCD栅栏
当任务需要异步进行，但是这些任务需要分成两组来执行，第一组完成之后才能进行第二组的操作。这时候就用了到GCD栅栏方法dispatch_barrier_async。
// 并发队列
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]);
}
});
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 onceToken;
dispatch_once(&onceToken, ^{
NSLog(@"程序运行过程中我只执行了一次！");
});
GCD快速迭代
GCD有一个快速迭代的方法dispatch_apply可以同时遍历多个数字。
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]);
});
GCD队列组
异步执行几个耗时操作，当这几个操作都完成之后再回到主线程进行操作，就可以用到队列组了。
使用队列组的特点
1、所有的任务会并发的执行(不按序)。
2、所有的异步函数都添加到队列中，然后再纳入队列组的监听范围。
3、使用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(@"队列组：前面的耗时操作都完成了，回到主线程进行相关操作");
});
}
NSOperation的理解与使用
NSOperation是基于GCD之上的更高一层封装，NSOperation需要配合NSOperationQueue来实现多线程。NSOperation实现多线程的步骤如下：
- 创建任务：先将需要执行的操作封装到NSOperation对象中。
- 创建队列：创建NSOperationQueue。
- 将任务加入到队列中：将NSOperation对象添加到NSOperationQueue中。
需要注意的是，NSOperation是个抽象类，实际运用时中需要使用它的子类，有三种方式：
NSInvocationOperation
// 创建NSInvocationOperation
NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperation) object:nil];
// 开始执行操作
[invocationOperation start];
NSBlockOperation
// 把任务放到block中
NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"NSBlockOperation包含的任务，没有加入队列========%@", [NSThread currentThread]);
}];
[blockOperation start];
上面两段代码都是在主线程执行，并没有开辟新的线程，因为NSInvocationOperation和NSBlockOperation需要配合NSOperationQueue来一起使用，但是，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];
}
定义继承自NSOperation的子类，通过实现内部相应的方法来封装任务。
我们可以定义一个继承自NSOperation的类，然后重写它的main方法，之后就可以使用这个子类来进行相关的操作了。
队列NSOperationQueue
NSOperationQueue只有两种队列：主队列、其他队列。其他队列包含了串行和并发。
主队列的创建如下，主队列上的任务是在主线程执行的。
NSOperationQueue *mainQueue = [NSOperationQueue mainQueue];
其他队列（非主队列）的创建如下，加入到‘非队列’中的任务默认就是并发，开启多线程。
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
注意：
- 非主队列（其他队列）可以实现串行或并行。
- 队列NSOperationQueue有一个参数叫做最大并发数：maxConcurrentOperationCount。
- maxConcurrentOperationCount默认为-1，直接并发执行，所以加入到‘非队列’中的任务默认就是并发，开启多线程。
- 当maxConcurrentOperationCount为1时，则表示不开线程，也就是串行。
- 当maxConcurrentOperationCount大于1时，进行并发执行。
- 系统对最大并发数有一个限制，所以即使程序员把maxConcurrentOperationCount设置的很大，系统也会自动调整。所以把最大并发数设置的很大是没有意义的。
NSOperation + NSOperationQueue
NSOperation和NSOperationQueue配合使用才是NSOperation正确的使用方式：
addOperation添加任务到队列
- (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];
}
addOperationWithBlock添加任务到队列
这是一个更方便的把任务添加到队列的方法，直接把任务写在block中，添加到任务中。
- (void)testAddOperationWithBlock {
// 创建队列，默认并发
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 添加操作到队列
[queue addOperationWithBlock:^{
for (int i = 0; i < 3; i++) {
NSLog(@"addOperationWithBlock把任务添加到队列======%@", [NSThread currentThread]);
}
}];
}
运用最大并发数实现串行
- (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的时候，虽然开启了线程，但是任务是顺序执行的，所以实现了串行。
NSOperation的其他操作
// 取消队列NSOperationQueue的所有操作，NSOperationQueue对象方法
- (void)cancelAllOperations
// 取消NSOperation的某个操作，NSOperation对象方法
- (void)cancel
// 使队列暂停或继续
// 暂停队列
[queue setSuspended:YES];
// 判断队列是否暂停
- (BOOL)isSuspended
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];
}
上面就是iOS多线程最常见的使用方法。但是，在使用多线程的工程中，一定要注意，因为多线程会有各种各样的安全隐患，最常见的就是当多个线程在访问同一块资源时，很容易引发数据错乱和数据安全问题。
多线程的安全隐患
资源共享
- 1块资源可能被多个线程共享，也就是多个线程可能会访问同一块资源
- 比如多个线程访问同一个对象，同一个变量，同一个文件
所以，当存在以上问题的时候，就会牵涉到另一个经典的解决问题的办法，线程同步技术，最常见的即加锁。
线程实现同步的两种锁：
- 自旋锁
互斥锁：在锁定的时候，其他线程会进入睡眠状态，等待条件满足时，重新唤醒。- 互斥锁
自旋锁：在锁定的时候，其他线程会进入一个死循环，也是一直在等待条件满足，一旦条件满足，立即执行，少了一个唤醒过程。
iOS中的线程同步方案
OSSpinLock
os_unfair_lock
pthread_mutex
dispatch_semaphore
dispatch_queue(DISPATCH_QUEUE_SERIAL)
NSLock
NSrecursiveLock
NSCondition
OSSpinLock（自旋锁）
#import
//初始化锁
OSSpinLock lock = OS_SPINLOCK_INIT;
//加锁
OSSpinLockLock(&lock);
//解锁
OSSpinLockUnlock(&lock);
注意：iOS10以后废弃，因为可能引发优先级反转的问题
os_unfair_lock
用来取代不安全的OSSpinLock，iOS10以后才开始，从底层看，等待os_unfair_lock锁的线程会处于休眠状态，并非忙等。
//初始化锁
os_unfair_lock lock = OS_UNFAIR_LOCK_INIT;
//加锁
os_unfair_lock_lock(&lock);
//解锁
os_unfair_lock_unlock(&lock);
pthread_mutex(互斥锁)
//初始化锁的属性
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
//初始化锁
pthread_mutex_t mutex;
pthread_mutex_init(&mutex, &attr);
//尝试加锁
pthread_mutex_trylock(&mutex);
//加锁
pthread_mutex_lock(&mutex);
//解锁
pthread_mutex_unlock(&mutex);
//销毁相关资源
pthread_mutexattr_destroy(&attr);
pthread_mutexattr_destroy(&mutex);
NSLock&NSrecursiveLock
NSLock是对mutex普通锁的封装，NSrecursiveLock是对mutex递归锁的封装，纯oc的对象，使用起来比较简单，直接alloc就可以了，可以看到相关的API，意思简单明了。
//初始化锁
NSLock *lock = [[NSLock alloc]init];
//加锁
[lock lock];
//解锁
[lock unlock];
NSCondition
NSCondition是对mutex和cont的封装
//等待
- (void)wait;
- (BOOL)waitUntilDate:(NSDate *)limit;
//信号
- (void)signal;
//广播
- (void)broadcast;
dispatch_queue
使用GCD的串行队列，也是可以实现线程同步的，因为线程同步的本质就是按顺序执行某个方法，那我串行队列也是可以做到的。
dispatch_queue_t queue = dispatch_queue_create("myQueue", DISPATCH_QUEUE_SERIAL);
dispatch_semaphore
//信号量的初始值
int value = 1;
//初始化信号量
dispatch_semaphore_t semaphore = dispatch_semaphore_create(value);
//如果信号量的值 <= 0，当前线程就会进入休眠等待（直到信号量 > 0）
//如果信号量的值 >= 0，就减1，然后往下执行后面的代码
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
//让信号量的值+1
dispatch_semaphore_signal(semaphore);
自旋锁互斥锁比较
什么情况下用自旋锁？
1、预计线程等待锁的时间很短
2、加锁的代码经常被调用，但竞争情况很少发生
3、CPU资源不紧张
4、多核处理器
什么情况下用互斥锁？
1、预计线程等待锁的时间比较长
2、单核处理器
3、临界区有IO操作
相信通过文章，大家对多线程有了更为相信的了解，文章有不对的地方希望大家可以多多指导，共同进步。