一、多线程基础知识回顾
1、iOS中常见多线程方案
多线程方案.png
2、iOS中常见多线程方案
GCD中两个执行任务的函数(queue：队列 block：任务)
2.1 GCD中两个执行任务的函数
- 同步执行的方式
// 在当前线程中执行任务，不具备开启新线程的能力
dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);
- 异步执行的方式
// 在新的线程中执行任务，具备开启新线程的能力
dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
2.2 GCD中的队列
- 并发队列（Concurrent Dispatch Queue）
* 可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）
* 并发功能只有在异步（dispatch_async）函数下才有效
- 串行队列（Serial Dispatch Queue）
* 让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）
-
2.3 各种队列和任务的执行效果执行效果.png
注意：
* 使用sync函数往当前串行队列中添加任务，会卡住当前的串行队列（产生死锁）
* 全局并发队列，内存中只有一个
- 2.4 队列组的使用
//创建队列组
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 < 1000; i++) {
NSLog(@"任务2-%@",[NSThread currentThread]);
}
});
// 等前面的任务执行完毕后，会在当前队列中执行任务
dispatch_group_notify(group, queue, ^{
dispatch_async(dispatch_get_main_queue(), ^{
for (int i = 0; i < 5; i++) {
NSLog(@"任务3-%@", [NSThread currentThread]);
}
});
});
二、多线程同步方案（解决安全隐患）
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
1、OSSpinLock： 在 iOS10开始被废弃
- 1.1、"自旋锁"，等待锁的线程会处于忙等（busy-wait）状态，一直占用着CPU资源(相当于while循环阻塞线程)
- 1.2、目前已经不再安全，可能会出现优先级反转问题：
当有多条线程的时候，优先级比较高的线程会优先占用lock(锁)，优先级相对较低的线程就无法加锁，只有等优先级高的线程先执行完才可以进行加锁和解锁。
- 1.3、使用
导入头文件#import <libkern/OSAtomic.h>
定义锁
@property(nonatomic,assign) OSSpinLock lock;
// 初始化锁
self.lock = OS_SPINLOCK_INIT;
// 加锁
OSSpinLockLock(&_lock);
加锁 和 解锁 中间放 多个线程访问的资源
// 解锁
OSSpinLockUnlock(&_lock);
2、os_unfair_lock（互斥锁）
- 2.1、从iOS10开始取代OSSpinLock
- 2.2、从底层调用看，等待os_unfair_lock锁的线程会处于休眠状态，并非忙等
- 2.3、需要导入头文件 #import <os/lock.h>
- 2.4、os_unfair_lock的使用：
导入头文件 #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);
3、pthread_mutex:(互斥锁)：
- 3.1、等待锁的线程会处于休眠状态
- 3.2、需要导入头文件 #import <pthread.h>
- 3.3、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 普通锁
- 3.4、有普通互斥锁，递归锁、有条件的互斥锁三种
4、NSLock:(互斥锁)：对mutex普通锁的封装
使用如下
// 定义锁的属性
@property(nonatomic,strong) NSLock *lock;
// 初始化锁
self. lock = [[NSLock alloc]init];
// 加锁
[self.lock lock];
加锁 和 解锁 中间放 多个线程访问的资源
// 解锁
[self.lock unlock];
5、NSRecursiveLock:也是对mutex递归锁的封装，API跟NSLock基本一致
使用如下
// 定义锁的属性
@property(nonatomic,strong) NSRecursiveLock *lock;
// 初始化锁
self. lock = [[NSRecursiveLock alloc]init];
// 加锁
[self.lock lock];
加锁 和 解锁 中间放 多个线程访问的资源
// 解锁
[self.lock unlock];
6、NSCondition(带有条件的互斥锁):是对mutex和cond的封装
使用如下
// 定义锁和条件的属性
@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];
7、NSConditionLock(带有条件的互斥锁):是对NSCondition的进一步封装，可以设置具体的条件值
使用如下：
// 定义锁和条件的属性
@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];
8、dispatch_queue (DISPATCH_QUEUE_SERIAL:串行)：
直接使用GCD的串行队列，也是可以实现线程同步的（只要能够保证在同一时间不共享一块资源就可以
使用如下：
// 创建全局队列
@property(nonatomic,strong) dispatch_queue_t ticketLock;
// 初始化队列(名字设置：ticketLock)
self.ticketLock = dispatch_queue_create("ticketLock", DISPATCH_QUEUE_SERIAL);
dispatch_sync(self.ticketLock, ^{
// 共享资源的代码
});
9、dispatch_semaphore信号量
- 9.1、信号量的初始值，可以用来控制线程并发访问的最大数量
- 9.2、信号量的初始值为1，代表同时只允许1条线程访问资源，保证线程同步
使用如下：
// 定义信号量变量
@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);
10、@synchronized(mutex递归锁的封装)
- 10.1、@synchronized是对mutex递归锁的封装
- 10.2、源码查看：objc4中的objc-sync.mm文件
- 10.3、@synchronized(obj)内部会生成obj对应的递归锁，然后进行加锁、解锁操作
@synchronized(obj){
任务
}
三、多线程同步方案性能比较
1、性能从高到低排序
- 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
2、自旋锁、互斥锁比较
-
2.1、什么情况使用自旋锁(占用CPU)比较划算？
- 预计线程等待锁的时间很短
- 加锁的代码（临界区）经常被调用，但竞争情况很少发生
- CPU资源不紧张
- 多核处理器
-
2.2、什么情况使用互斥锁比较划算？
- 预计线程等待锁的时间较长
- 单核处理器
- 临界区有IO操作（文件的读写操作）
- 临界区代码复杂或者循环量大
- 临界区竞争非常激烈
四、iOS中的读写安全方案
1、读写安全目标：
- 1.1、同一时间，只能有1个线程进行写的操作
- 1.2、同一时间，允许有多个线程进行读的操作
- 1.3、同一时间，不允许既有写的操作，又有读的操作
2、读写安全方案：
- 2.1、pthread_rwlock：读写锁
- 2.2、dispatch_barrier_async：异步栅栏调用
3、pthread_rwlock：读写锁(互斥锁)
使用方法如下：
#import "Pthread_rwlock.h"
#import <pthread.h>
@interface Pthread_rwlock ()
property (assign, nonatomic) pthread_rwlock_t lock;
@end
@implementation Pthread_rwlock
- (instancetype)init{
if (self = [super init]) {
[self createFunction];
}
return self;
}
-(void)createFunction{
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
4、pthread_rwlock：读写锁(互斥锁)
- 这个函数传入的并发队列必须是自己通过dispatch_queue_cretate创建的
- 如果传入的是一个串行或是一个全局的并发队列，那这个函数便等同于dispatch_async函数的效果
self.queue = dispatch_queue_create("rw_queue", DISPATCH_QUEUE_CONCURRENT);
for (int i = 0; i<10; i++) {
dispatch_async(self.queue, ^{
[self read];
});
dispatch_async(self.queue, ^{
[self write];
});
}
一、定时器 （CADisplayLink、NSTimer、GCD）
1、CADisplayLink、NSTimer
如果target对CADisplayLink、NSTimer进行引用，那么就会引发循环引用，如下办法解决：
1、使用NSTimer 的block方法
__weak typeof(self) weakSelf = self;
2、通过中间对象(代理对象)的方式来解决
ZMJProxy *proxy = [ZMJProxy proxyWithTarget:vc];
ZMJProxy1 *proxy1 = [ZMJProxy1 proxyWithTarget:vc];
//判断是否是这个类或者这个类的子类的实例
NSLog(@"%d %d",[proxy isKindOfClass:[ViewController class]],[proxy1 isKindOfClass:[ViewController class]]);
继承NSProxy会进行消息转发 ， 通过target调用方法
2、定时器 （GCD）
比较准时，它直接和系统内核挂钩的(NSTimer依赖于RunLoop，如果RunLoop的任务过于繁重，可能会导致NSTimer不准时
//创建队列
// dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_queue_t queue = dispatch_queue_create("timer", DISPATCH_QUEUE_SERIAL);
/*
创建定时器
1、 intervalInSeconds 时间值 多少秒后开始执行
2、 leewayInSeconds 时间间隔 多长时间开始执行
*/
dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
dispatch_source_set_timer(timer, DISPATCH_TIME_NOW, 2.0 * NSEC_PER_SEC, 1.0 * NSEC_PER_SEC);
//第一种方法：
// dispatch_source_set_event_handler(timer, ^{
// NSLog(@"111111111");
// });
//第二种方法：
dispatch_source_set_event_handler_f(timer, timerFire);
dispatch_resume(timer);
self.timer = timer;
