一、简介：多线程在之前进行过一篇详细的基础博客 iOS多线程
二、多线程的基础知识回顾
- 1.1、iOS中的常见多线程方案
| 技术方案 | 简介 | 语言 | 线程生命周期 | 使用频率 |
|---|---|---|---|---|
pthread |
一套通用的多线程API;适用于Unix\Linux\Windows等系统;跨平台\可移植;使用难度大 |
C语言 | 程序员管理 | 几乎不用 |
NSThread |
使用更加面向对象；简单易用，可直接操作线程对象 | OC | 程序员管理 | 偶尔使用 |
GCD |
旨在替代NSThread等线程技术；充分利用设备的多核 | C | 自动管理 | 经常使用 |
NSOperation |
基于GCD（底层是GCD）；比GCD多了一些更简单实用的功能；使用更加面向对象 | OC | 自动管理 | 经常使用 |
-
1.2、GCD中有2个用来执行任务的函数(queue：队列 block：任务)
-
用同步的方式执行任务
dispatch_sync(dispatch_queue_t queue, dispatch_block_t block); -
用异步的方式执行任务
dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
-
-
1.3、GCD的队列可以分为2大类型
- 并发队列（Concurrent Dispatch Queue）
- 可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）
- 并发功能只有在异步（dispatch_async）函数下才有效
- 串行队列（Serial Dispatch Queue）
- 让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）
- 并发队列（Concurrent Dispatch Queue）
-
1.4、有4个术语比较容易混淆：
同步、异步、并发、串行- 同步(
dispatch_sync)和异步(dispatch_async)主要影响：能不能开启新的线程- 同步：在当前线程中执行任务，不具备开启新线程的能力
- 异步：在新的线程中执行任务，具备开启新线程的能力
-
并发和串行主要影响：任务的执行方式
- 并发：多个任务并发（同时）执行
- 串行：一个任务执行完毕后，再执行下一个任务
- 同步(
-
1.5、各种队列的执行效果
各种队列的执行效果
注意:使用sync函数往当前串行队列中添加任务，会卡住当前的串行队列。如下：#pragma mark 看下面的代码是否会产生死锁：会 // 队列的特点：排队，FIFO，First In First Out，先进先出 -(void)interview1{ NSLog(@"---------1-------"); dispatch_queue_t queue = dispatch_get_main_queue(); dispatch_sync(queue, ^{ NSLog(@"---------2-------"); }); // dispatch_sync: 立马在当前线程执行任务，执行完毕才能继续往下执行 NSLog(@"---------3-------"); }总结：只要不存在谁等谁的情况就不会有线程的阻塞
-
1.6、看下面的打印结果
-(void)interview6{ dispatch_queue_t queue = dispatch_get_global_queue(0, 0); dispatch_async(queue, ^{ NSLog(@"1"); // 这句代码的本质是往Runloop中添加定时器 [self performSelector:@selector(test) withObject:nil afterDelay:.0]; /** 没有添加定时器（test可以立马执行） [self performSelector:@selector(test) withObject:nil]; */ NSLog(@"3"); }); } -(void)test{ NSLog(@"2"); }打印结果是：1、3
原因：performSelector:withObject:afterDelay:这句代码的本质是往Runloop中添加定时器 子线程默认没有启动Runloop 可以添加下面的代码来启动RunLoop [[NSRunLoop currentRunLoop]addPort:[[NSPort alloc]init] forMode:NSDefaultRunLoopMode]; [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]]; 1.7、GNUstep 是GNU计划的项目之一，它将Cocoa的OC库重新开源实现了一遍
三、多线程 GCD 队列组：notify(唤醒)
// 创建队列组
dispatch_group_t group = dispatch_group_create();
// 创建并发队列
dispatch_queue_t queue = dispatch_queue_create("my_queue", DISPATCH_QUEUE_CONCURRENT);
// 添加异步任务
dispatch_group_async(group, queue, ^{
for (int i = 0; i < 5; i++) {
NSLog(@"任务1-%@", [NSThread currentThread]);
}
});
dispatch_group_async(group, queue, ^{
for (int i = 0; i < 5; i++) {
NSLog(@"任务2-%@", [NSThread currentThread]);
}
});
下面使用唤醒代码（和上面的代码是连着的）
- 3.1、唤醒后在主线程执行任务
// 等前面的任务执行完毕后，会自动执行这个任务
dispatch_group_notify(group, queue, ^{
// async 异步，dispatch_get_main_queue() 主线程
dispatch_async(dispatch_get_main_queue(), ^{
for (int i = 0; i < 5; i++) {
NSLog(@"任务3-%@", [NSThread currentThread]);
}
});
});
-
3.2、唤醒后在主线程执行任务
dispatch_group_notify(group, dispatch_get_main_queue(), ^{ for (int i = 0; i < 5; i++) { NSLog(@"任务3-%@", [NSThread currentThread]); } }); -
3.3、唤醒后再执行另外两个子线程任务
dispatch_group_notify(group, queue, ^{ for (int i = 0; i < 5; i++) { NSLog(@"任务3-%@", [NSThread currentThread]); } }); dispatch_group_notify(group, queue, ^{ for (int i = 0; i < 5; i++) { NSLog(@"任务4-%@", [NSThread currentThread]); } });
四、多线程安全隐患: 常见的是 买票 与 存钱取钱
-
4.1、多线程安全隐患在什么情况下会出现
-
资源共享
- 1块资源可能会被多个线程共享，也就是多个线程可能会访问同一块资源
- 比如多个线程访问同一个对象、同一个变量、同一个文件
当多个线程访问同一块资源时，很容易引发数据错乱和数据安全问题
-
-
4.2、安全隐患的展示：(买票)
安全隐患的展示：(买票)/** 票的数量 */ @property(nonatomic,assign) int ticketCount; -(void)ticketTest{ // 放出 20张票 self.ticketCount = 20; dispatch_queue_t queue = dispatch_get_global_queue(0, 0); dispatch_async(queue, ^{ for (int i = 0; i<10; i++) { [self buyTicket]; } }); dispatch_async(queue, ^{ for (int i = 0; i<10; i++) { [self buyTicket]; } }); } // 线程调用买票 -(void)buyTicket{ int oldTickCount = self.ticketCount; sleep(0.2); oldTickCount --; self.ticketCount = oldTickCount; NSLog(@"还有%d张票-%@",oldTickCount,[NSThread currentThread]); }调用ticketTest 看下面的打印结果(数据错乱)
调用ticketTest 看下面的打印结果 -
4.3、安全隐患的展示：(存钱与取钱)
安全隐患的展示：(存钱与取钱)/** 钱的数量 */ @property(nonatomic,assign) int moneyCount; #pragma mark 9.取钱存钱的测试(多线程安全的隐患) -(void)moneyTest{ self.moneyCount = 100; dispatch_queue_t queue = dispatch_get_global_queue(0, 0); dispatch_async(queue, ^{ for (int i = 0; i<10; i++) { // 存钱 [self saveMoney]; } }); dispatch_async(queue, ^{ for (int i = 0; i<10; i++) { // 取钱 [self drawMoney]; } }); } // 存钱 -(void)saveMoney{ int oldMoney = self.moneyCount; sleep(0.2); oldMoney = oldMoney + 50; self.moneyCount = oldMoney; NSLog(@"存进去50元，余额是%d - %@",oldMoney,[NSThread currentThread]); } // 取钱 -(void)drawMoney{ int oldMoney = self.moneyCount; sleep(0.2); oldMoney = oldMoney - 20; self.moneyCount = oldMoney; NSLog(@"花去20元，余额是%d - %@",oldMoney,[NSThread currentThread]); }调用moneyTest 看下面的打印结果(数据错乱)
调用moneyTest 看下面的打印结果(数据错乱) -
4.4、多线程安全隐患分析图
-
由下图也可以看出 同一块资源在同一个时间段有多个线程访问，这样能够造成资源混乱
多线程安全隐患分析图
-
由下图也可以看出 同一块资源在同一个时间段有多个线程访问，这样能够造成资源混乱
-
4.5、多线程安全隐患的解决方案
-
解决方案：使用线程同步技术（同步，就是协同步调，按预定的先后次序进行） - 常见的
线程同步技术是：加锁 - 由下图也可以看出 同一块资源在同一个时间段只能由一个线程访问
-
五、iOS中的线程同步方案（下面锁的调用都在 ThreadLockViewController里面，锁的封装在JKBaseCode）：锁使用的demo
-
5.1、目前我所知道的有如下 10 种
1、OSSpinLock
2、os_unfair_lock
3、pthread_mutex
4、dispatch_semaphore
5、dispatch_queue(DISPATCH_QUEUE_SERIAL)
6、NSLock
7、NSRecursiveLock
8、NSCondition
9、NSConditionLock
10、@synchronized -
5.2、OSSpinLock (自旋锁)Height-level lock 多线程的demo:
OSSpinLockDemo与OSSpinLockDemo2里面有对买票和存钱取钱的自旋锁使用OSSpinLock叫做”自旋锁”，等待锁的线程会处于忙等（busy-wait）状态，一直占用着CPU资源(相当于while循环阻塞线程)
'OSSpinLock' is deprecated: first deprecated in iOS 10.0 - Use os_unfair_lock() from <os/lock.h> instead(在iOS10 被os_unfair_lock取代)
-
目前已经不再安全，可能会出现优先级反转问题
-
如果等待锁的线程优先级较高，它会一直占用着CPU资源，优先级低的线程就无法释放锁
OSSpinLock (自旋锁)
-
-
OSSpinLock 使用如下：（具体的可以看demo）
导入头文件#import <libkern/OSAtomic.h> 定义锁 @property(nonatomic,assign) OSSpinLock lock; // 初始化锁 self.lock = OS_SPINLOCK_INIT; // 加锁 OSSpinLockLock(&_lock); 加锁 和 解锁 中间放 多个线程访问的资源 // 解锁 OSSpinLockUnlock(&_lock); 分析：OSSpinLock 不再安全是因为会出现优先级反转问题，当有多条线程的时候，优先级比较高的线程会优先占用lock(锁)，优先级相对较低的线程就无法加锁，只有等优先级高的线程先执行完才可以进行加锁和解锁。
-
5.3、os_unfair_lock (互斥锁)Low-level lock
-
os_unfair_lock用于取代不安全的OSSpinLock ，从
iOS10开始才支持- 从底层调用看，等待
os_unfair_lock锁的线程会处于休眠状态，并非忙等 - 需要导入头文件
#import <os/lock.h>
os_unfair_lock：互斥锁
- 从底层调用看，等待
-
os_unfair_lock 使用如下：（具体的可以看demo）
导入头文件 #import <os/lock.h> 定义锁 @property(nonatomic,assign) os_unfair_lock lock; // 初始化锁 self.lock = OS_SPINLOCK_INIT; // 加锁 os_unfair_lock_lock(&_lock); 加锁 和 解锁 中间放 多个线程访问的资源 // 解锁 os_unfair_lock_unlock(&_lock);
-
-
5.4、pthread_mutex:(互斥锁)Low-level lock
mutex：
英[m'ju:teks]叫做“互斥锁”，等待锁的线程会处于休眠状态需要导入头文件
#import <pthread.h>-
Mutex type attributes 有如下四种类型
-
#define PTHREAD_MUTEX_NORMAL 0普通锁 -
#define PTHREAD_MUTEX_ERRORCHECK 1检查错误的锁 -
#define PTHREAD_MUTEX_RECURSIVE 2递归锁 -
#define PTHREAD_MUTEX_DEFAULT PTHREAD_MUTEX_NORMAL普通锁
pthread_mutex
-
-
具体的使用(不懂的看demo)
// 静态初始化 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; // 初始化属性 pthread_mutexattr_t attr; pthread_mutexattr_init(&attr); pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_DEFAULT); // 初始化锁 pthread_mutex_init(mutex, &attr); // 销毁属性 pthread_mutexattr_destroy(&attr); // 加锁 pthread_mutex_lock(&mutex); 加锁 和 解锁 中间放 多个线程访问的资源 // 解锁 pthread_mutex_unlock(&_ticketMutex); // 销毁相关资源 - (void)dealloc { pthread_mutex_destroy(&_ticketMutex); pthread_mutex_destroy(&_moneyMutexk); } -
有关 递归锁 的使用请看demo里面的
Pthread_mutexLockDemo2
pthread_mutex – 递归锁 -
带有条件的互斥锁
pthread_mutex_t,看demo里面的Pthread_mutexLockDemo3(应用场景是：一条线程的执行需要等待另外一条线程先执行，可以加等待条件condition)
pthread_mutex – 条件
-
5.5、NSLock:(互斥锁)：对mutex普通锁的封装
NSLock:(**互斥锁**)- 使用如下：
// 定义锁的属性 @property(nonatomic,strong) NSLock *lock; // 初始化锁 self. lock = [[NSLock alloc]init]; // 加锁 [self.lock lock]; 加锁 和 解锁 中间放 多个线程访问的资源 // 解锁 [self.lock unlock]; -
5.6、NSRecursiveLock:也是对mutex递归锁的封装，API跟NSLock基本一致
NSRecursiveLock-
使用如下：
// 定义锁的属性 @property(nonatomic,strong) NSRecursiveLock *lock; // 初始化锁 self. lock = [[NSRecursiveLock alloc]init]; // 加锁 [self.lock lock]; 加锁 和 解锁 中间放 多个线程访问的资源 // 解锁 [self.lock unlock];
-
-
5.7、NSCondition(带有条件的互斥锁):是对mutex和cond的封装
NSCondition(带有条件的互斥锁)-
使用如下：
// 定义锁和条件的属性 @property(nonatomic,strong) NSCondition *conditLock; // 初始化锁和条件 self. conditLock = [[NSCondition alloc]init]; // 加锁 [self. conditLock lock]; // 等待(等待的条件和唤醒的条件 cond 必须保持一致) [self.conditLock wait]; 加锁 和 解锁 中间放 多个线程访问的资源 // 唤醒等待 [self.conditLock signal]; // 广播 (唤醒所有等待的条件 cond 必须保持一致) // [self.conditLock broadcast]; // 解锁 [self. conditLock unlock];
-
-
5.8、NSConditionLock(带有条件的互斥锁):是对NSCondition的进一步封装，可以设置具体的条件值
NSConditionLock-
使用如下：(适用环境：根据条件设置线程的执行顺序，比如两个网络请求，第2个依赖于第一个的结果，那就就可以设置条件)
// 定义锁和条件的属性 @property(nonatomic,strong) NSConditionLock *conditLock; // 初始化锁和条件(initWithCondition:跟的是条件) self.conditLock = [[NSConditionLock alloc]initWithCondition:1]; // 不写条件的话默 条件 为 0 // self.conditLock = [[NSConditionLock alloc]init]; // 加锁(根据条件是否相同进行加锁) [self.conditLock lockWhenCondition:1]; 加锁 和 解锁 中间放 多个线程访问的资源 // 解锁(解锁的条件随便写：如果解锁后要执行其他的线程，可以设置和其他的线程匹配的条件) [self.conditLock unlockWithCondition:2];
-
-
5.9、dispatch_queue (
DISPATCH_QUEUE_SERIAL:串行)：直接使用GCD的串行队列，也是可以实现线程同步的（只要能够保证在同一时间不共享一块资源就可以）-
使用如下：(具体的代码看demo里面的
Dispatch_queueDemo)// 创建全局队列 @property(nonatomic,strong) dispatch_queue_t ticketLock; // 初始化队列(名字设置：ticketLock) self.ticketLock = dispatch_queue_create("ticketLock", DISPATCH_QUEUE_SERIAL); dispatch_sync(self.ticketLock, ^{ // 共享资源的代码 });
-
-
5.10、dispatch_semaphore (也是最大并发数：只要设置为
1就可以只执行一件事)semaphore叫做"信号量"信号量的初始值，可以用来控制线程并发访问的最大数量
-
信号量的初始值为1，代表同时只允许1条线程访问资源，保证线程同步
semaphore 信号量 -
使用如下：
// 定义信号量变量 @property (strong, nonatomic) dispatch_semaphore_t semaphore; // 初始化信号量变量 self. semaphore = dispatch_semaphore_create(1); // 如果信号量的值 > 0，就让信号量的值减1，然后继续往下执行代码 // 如果信号量的值 <= 0，就会休眠等待，直到信号量的值变成>0，就让信号量的值减1，然后继续往下执行代码 dispatch_semaphore_wait(self. semaphore, DISPATCH_TIME_FOREVER); 多个线程访问的资源 dispatch_semaphore_signal(self. semaphore);
-
5.11、@synchronized(mutex递归锁的封装)
- @synchronized是对mutex递归锁的封装
- 源码查看：objc4中的objc-sync.mm文件
-
@synchronized(obj)内部会生成obj对应的递归锁，然后进行加锁、解锁操作
@synchronized是对mutex递归锁的封装
-
5.12、iOS 线程同步方案性能比较(推荐使用下面的第3和第4)
性能从高到低排序
- os_unfair_lock ：从iOS10开始才支持(互斥锁)
- OSSpinLock ：在iOS10 被os_unfair_lock取代
- dispatch_semaphore
- pthread_mutex
- dispatch_queue(DISPATCH_QUEUE_SERIAL)
- NSLock
- NSCondition
- pthread_mutex(recursive)
- NSRecursiveLock
- NSConditionLock
- @synchronized
-
5.13、自旋锁、互斥锁比较
- 什么情况使用自旋锁(占用CPU)比较划算？
- 预计线程等待锁的时间很短
- 加锁的代码（临界区）经常被调用，但竞争情况很少发生
- CPU资源不紧张
- 多核处理器
- 什么情况使用互斥锁比较划算？
- 预计线程等待锁的时间较长
- 单核处理器
- 临界区有IO操作（文件的读写操作）
- 临界区代码复杂或者循环量大
- 临界区竞争非常激烈
- 什么情况使用自旋锁(占用CPU)比较划算？
六、iOS中的读写安全方案
-
6.1、思考如何实现以下场景
- 同一时间，只能有1个线程进行写的操作
- 同一时间，允许有多个线程进行读的操作
- 同一时间，不允许既有写的操作，又有读的操作
-
6.2、上面的场景就是典型的“多读单写”，经常用于文件等数据的读写操作，iOS中的实现方案有
-
pthread_rwlock：读写锁 -
dispatch_barrier_async：异步栅栏调用
-
-
6.3、pthread_rwlock：读写锁(互斥锁)
等待锁的线程会进入休眠
pthread_rwlock读写锁(**互斥锁**)具体的代码：（具体的可以看demo里面的
Pthread_rwlockViewController控制器里面的代码）读可以多条线程进行
-
在写的时候没有读的操作 且 写只能有一条线程进行
#import "Pthread_rwlockViewController.h" #import <pthread.h> @interface Pthread_rwlockViewController () property (assign, nonatomic) pthread_rwlock_t lock; @end @implementation Pthread_rwlockViewController - (void)viewDidLoad { [super viewDidLoad]; self.view.backgroundColor = [UIColor whiteColor]; dispatch_queue_t queue = dispatch_get_global_queue(0, 0); pthread_rwlock_init(&_lock, NULL); for (int i = 0; i<10; i++) { dispatch_async(queue, ^{ [self read]; }); dispatch_async(queue, ^{ [self write]; }); } } // 读文件 -(void)read{ // 读可以多条线程进行 pthread_rwlock_rdlock(&_lock); sleep(1.0); NSLog(@"--读--"); pthread_rwlock_unlock(&_lock); } // 写文件 -(void)write{ // 在写的时候没有读的操作 且 写只能有一条线程进行 pthread_rwlock_wrlock(&_lock); sleep(1.0); NSLog(@"--写--"); pthread_rwlock_unlock(&_lock); } @end
-
6.4、dispatch_barrier_async
- 这个函数传入的并发队列必须是自己通过dispatch_queue_cretate创建的
-
如果传入的是一个串行或是一个全局的并发队列，那这个函数便等同于dispatch_async函数的效果
dispatch_barrier_async - 具体的代码看demo里面
Dispatch_barrier_asyncViewController控制器
6.5、这是上面所有代码的demo
