iOS 多线程最全总结

一、iOS中常见的多线程方案

1、pthread

• 一套通用的多线程API
• 适用于Unix\Linux\Windows等系统
• 跨平台、可移植
• 使用难度大
• 使用C语言
• 程序员管理线程生命周期
• 实际项目中几乎不用

2、NSThread

• 使用更加面向对象
• 简单易用、可直接操作线程对象
• 使用OC语言
• 程序员管理线程生命周期
• 实际项目中几乎不用

3、GCD

• 旨在替代NSThread技术
• 充分利用设备的多核
• 使用C语言
• 自动管理线程生命周期
• 实际项目中经常使用

4、NSOperation

• 基于GCD（底层是GCD）
• 比GCD多了一些简单实用的功能
• 使用更加面向对象
• 使用OC语言
• 自动管理线程生命周期
• 实际项目中经常使用

在项目中更多的时候我们使用的是GCD。

image.png

二、GCD

1、GCD有两个用来执行任务的函数

• 同步（sync）：只能在当前线程中执行任务，不具备开启新线程的能力，任务立刻马上执行，会阻塞当前线程并等待 Block中的任务执行完毕dispatch函数才会返回，然后当前线程才会继续往下运行。
• 异步（async）：可以在新的线程中执行任务，具备开启线程的能力，但不一定会开启新的线程，dispatch函数会立即返回, 然后Block在后台异步执行，即当前线程会直接往下执行，不会阻塞当前线程。

相关代码如下：

#pragma mark - 同步执行
- (void)syncQueue {
    NSLog(@"同步主线程开始");
    //创建串行队列
    dispatch_queue_t queue = dispatch_queue_create("com.weixin.globalQueue", DISPATCH_QUEUE_SERIAL);
    dispatch_sync(queue, ^{
        NSLog(@"同步线程");
    });
    NSLog(@"同步主线程结束");
}

#pragma mark - 异步执行
- (void)asyncQueue {
    NSLog(@"异步主线程开始");
    dispatch_queue_t queue = dispatch_queue_create("com.qq.globalQueue", DISPATCH_QUEUE_SERIAL);
    dispatch_async(queue, ^{
        NSLog(@"异步线程");
    });
    NSLog(@"异步主线程结束");
}

结果如下： WX20180119-162214.png

2、队列

用于存放任务，分为串行队列和并行队列。

• 串行队列：所有任务会在一条线程中执行（有可能是当前线程也有可能是新开辟的线程），并且一个任务执行完毕后，才开始执行下一个任务。

• 并行队列：可以开启多条线程并行执行任务（但不一定会开启新的线程），并且当一个任务放到指定线程开始执行时，下一个任务就可以开始执行了

• 创建队列：

1. 串行队列

//创建串行队列
dispatch_queue_t firstQueue = dispatch_queue_create("com.weibo", DISPATCH_QUEUE_SERIAL);

2. 并行队列

//创建并行队列
dispatch_queue_t secondQueue = dispatch_queue_create("com.facebook", DISPATCH_QUEUE_CONCURRENT);

3. 创建全局默认并发队列

//创建全局默认并发队列
/**
   第一个参数:优先级 也可直接填后面的数字
   #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 // 后台
   第二个参数: 预留参数  0
*/
dispatch_queue_t queue3 = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

4. 获取主队列

//获取主队列
dispatch_queue_t mainQueue = dispatch_get_main_queue();

• 
• 

5、任务队列组合

image.png

死锁的问题

使用同步sync函数向当前的串行queue中添加任务，会卡住当前串行队列，产生死锁。

6、队列组
dispatch_group_async & dispatch_group_notify
代码以及说明如下：

#pragma mark - 队列组
- (void)GCDGroup {
    //创建队列组
    dispatch_group_t group = dispatch_group_create();
    //1.开子线程下载图片
    //创建队列(并发)
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    //下载图片1
    dispatch_group_async(group, queue, ^{
        NSURL *url = [NSURL URLWithString:@"http://www.huabian.com/uploadfile/2015/0914/20150914014032274.jpg"];
        NSData *data = [NSData dataWithContentsOfURL:url];
        self.image1 = [UIImage imageWithData:data];
        NSLog(@"image1 ==== %@",self.image1);
    });
    
    //下载图片2
    dispatch_group_async(group, queue, ^{
        NSURL *url = [NSURL URLWithString:@"http://img1.3lian.com/img2011/w12/1202/19/d/88.jpg"];
        NSData *data = [NSData dataWithContentsOfURL:url];
        self.image2 = [UIImage imageWithData:data];
        NSLog(@"image2 ==== %@",self.image2);
    });
    
    //group中所有任务执行完毕，通知该方法执行
    dispatch_group_notify(group, queue, ^{
        //开启图形上下文
        UIGraphicsBeginImageContext(CGSizeMake(200, 200));
        //画1
        [self.image1 drawInRect:CGRectMake(0, 0, 200, 100)];
        //画2
        [self.image2 drawInRect:CGRectMake(0, 100, 200, 100)];
        //根据图形上下文拿到图片
        UIImage *image =  UIGraphicsGetImageFromCurrentImageContext();
        //关闭上下文
        UIGraphicsEndImageContext();
        //回到主线程刷新UI
        dispatch_async(dispatch_get_main_queue(), ^{
            self.imageView.image = image;
            NSLog(@"%@--刷新UI",[NSThread currentThread]);
        });
    });
}

注意：队列组一般用来比如进入一个页面，同时异步请求多个接口，然后再所有接口请求完毕后，再返回主线程刷新UI。

三、面试题

1、

image.png

2、atomic和nonatomic的区别
给属性加上atomic修饰，可以保证属性的getter和setter方法都是原子性操作（最小单位一个整体），也就是说保证setter和getter的内部是线程同步的，在内部会在调用set和get方法前后进行加锁和解锁的操作。
但实际中很少有用到atomic，因为实在太耗费性能了，频繁的调用属性，频繁的加锁解锁。

四、iOS的各种锁

多个线程同时操作同一块的资源，会引起数据的错误混乱
经典问题：存储钱、卖票

解决方案：采用线程同步技术
常见的线程同步技术：加锁

1、OSSpinLock自旋锁

• OSSpinLock叫做“自旋锁”，等待锁的线程会处于忙等状态，一直占用着CPU的资源，他不睡觉。
• 目前这个锁已经不安全，可能出现优先级反转的问题。
• 如果等待锁的线程优先级高，它会一直占用着CPU资源，优先级低的线程就无法释放。
• 所以在10.0以后这个OSSpinLock就被废弃不再使用了。

2、os_unfair_lock

• 用于取代不安全的OSSpinLink，从iOS10开始支持
• os_unfair_lock是一种互斥锁，它不会向自旋锁那样忙等，而是等待线程会休眠

os_unfair_lock unfairLock = OS_UNFAIR_LOCK_INIT;
os_unfair_lock_lock(&unfairLock);
os_unfair_lock_unlock(&unfairLock);

3、pthread_mutex

• 互斥锁，等待锁的线程会处于休眠状态
• 跨平台的 Unix Linux Windows iOS等都可以使用
• 导入头文件<pthread.h>
• pthread_mutex(recursive) 递归锁
  加锁后只能有一个线程访问该对象，后面的线程需要排队，并且 lock 和 unlock 是对应出现的，同一线程多次 lock 是不允许的，而递归锁允许同一个线程在未释放其拥有的锁时反复对该锁进行加锁操作。不用的线程用递归锁，其他线程也要等待unlock才行。

static pthread_mutex_t pLock;
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr); //初始化attr并且给它赋予默认
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); //设置锁类型，这边是设置为递归锁
pthread_mutex_init(&pLock, &attr);
pthread_mutexattr_destroy(&attr); //销毁一个属性对象，在重新进行初始化之前该结构不能重新使用，初始化完要销毁

//1.线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    static void (^RecursiveBlock)(int);
    RecursiveBlock = ^(int value) {
        pthread_mutex_lock(&pLock);
        if (value > 0) {
            NSLog(@"value: %d", value);
            RecursiveBlock(value - 1);
        }
        pthread_mutex_unlock(&pLock);
    };
    RecursiveBlock(5);
});

4、NSLock

NSLock是对mutex普通锁的封装。

@protocol NSLocking

- (void)lock;
- (void)unlock;

@end

@interface NSLock : NSObject <NSLocking> {
@private
    void *_priv;
}

- (BOOL)tryLock;
- (BOOL)lockBeforeDate:(NSDate *)limit;

@property (nullable, copy) NSString *name API_AVAILABLE(macos(10.5), ios(2.0), watchos(2.0), tvos(9.0));

@end

tryLock 和 lock 方法都会请求加锁，唯一不同的是trylock在没有获得锁的时候可以继续做一些任务和处理。lockBeforeDate方法也比较简单，就是在limit时间点之前获得锁，没有拿到返回NO。

5、NSRecursiveLock

• 递归锁有一个特点，递归锁可以被同一线程多次请求，而不会引起死锁。这主要是用在循环或递归操作中。
• 是对pthread_mutex递归的封装

6、NSCondition

• 条件锁
  定义：
  是对pthread_mutex中锁以及条件的封装

@interface NSCondition : NSObject <NSLocking> {
@private
    void *_priv;
}

- (void)wait;
- (BOOL)waitUntilDate:(NSDate *)limit;
- (void)signal;
- (void)broadcast;

wait：进入等待状态
waitUntilDate:：让一个线程等待一定的时间
signal：唤醒一个等待的线程
broadcast：唤醒所有等待的线程

7、dispatch_semaphore信号量

GCD信号量的应用场景，一般是控制最大并发量，控制资源的同步访问，如数据访问，网络同步加载等。
用法：

• 创建信号量

dispatch_semaphore_t semaphore = dispatch_semaphore_create(2);

信号量的数量初始化，最好就是使用要执行任务的多少来定，如题是两次，则设置为2。

• 信号量-1

dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

每次执行一个任务，调用方法dispatch_semaphore_wait，让信号量减1
如果信号量的值>0，择让信号量的值减1，然后继续执行下面的代码；
如果信号量的值<=0，就会等待休眠，直到信号量的值变成>0，择继续减1，然后执行下面的代码

• 信号量+1

dispatch_semaphore_signal(semaphore);

每次结束一个任务，调用方法dispatch_semaphore_signal，让信号量+1

注意：
也有一些用法是设置信号量为0的，进入任务的时候signal，离开任务的时候wait。

8、@synchronized

实际项目中：AFNetworking中 isNetworkActivityOccurring属性的getter方法

- (BOOL)isNetworkActivityOccurring {
    @synchronized(self) {
        return self.activityCount > 0;
    }
}

各种锁的性能对比

image.png

自旋锁与互斥锁的比较

image.png