一、基础概念
有4个术语比较容易混淆:同步、异步、并发、串行
1.进程和线程
进程:进程是计算机中已运行程序的实体,是线程的容器。每个进程之间是相互独立的,每个进程均运行在专用且受保护的内存空间内。 把工厂作为一个系统,进程类似于车间。
线程:线程是操作系统能够进行运算调度的最小单位。一个进程的所有任务都在线程中执行。一个线程中执行的任务是串行的,同一时间内1个线程只能执行一个任务。 把工厂作为一个系统,线程类似于车间里干活的工人。
进程和线程之间关系
- 线程是CPU调用的最小单位
- 进程手机CPU分配资源的最小单位
- 一个进程中至少有一个线程
- 同一个进程内的线程共享进程的资源
多线程:一个进程可以开启多条线程,每条线程可以同时执行不同的任务,多线程技术可以提高程序的执行效率。同一时间内,CPU只能处理1条线程,只有1条线程在工作,多线程并发执行,其实是CPU快速的在多条线程之间调度,如果CPU调度线程的时间足够快,就造成了多线程并发执行的假象。CPU在多条线程之间调度会消耗大量的CPU资源,同时每条线程被调度的频次会降低,因此我们只开辟3-5条线程。
多线程优缺点
- 优点:1、能适当提高程序的执行效率;2、能适当提高资源利用率(CPU,内存利用率)
- 缺点: 1、创建线程的开销,在iOS中,内核数据结构(大约1kb)、栈空间(子线程512kb,主线程1MB)创建线程大约需要90毫秒的创建时间,如果开启大量线程会降低程序性能,线程越多,CPU在调度线程上的开销就越大。
线程的状态
- 创建:实例化对象
- 就绪:向线程对象发送start消息,线程对象被加入 “可调度线程池”,等待CPU调度,detach 方法 和 performSelectorInBackground 方法会直接实例化一个线程对象并加入 “可调度线程池”
- 运行:CPU 负责调度 “可调度线程池”中线程的执行,线程执行完成之前,状态可能会在 “就绪” 和 “运行” 之间来回切换,此过程CPU控制。
- 阻塞:当满足某个预定条件时,可以使用休眠或锁阻塞线程执行,影响的方法有:sleepForTimeInterval, sleepUntilDate, @synchronized(self) 线程锁。线程对象进入阻塞状态后,会被“可调度线程池” 中移除,CPU不再调度。
- 死亡:死亡后线程对象的 isFinished 属性为YES;如果发送cancel消息,线程对象的 isCanceled 属性为YES;死亡后 stackSize == 0, 内存空间被释放。
1.同步和异步
同步和异步主要影响:
- 能不能开启新的线程。
- 会不会阻塞当前线程。
同步:在当前线程中执行任务,不具备开启新线程的能力
异步:在新的线程中执行任务,具备开启新线程的能力(具备开线程的能力,但不一定会开线程)
2.并发和串行
并发和串行主要影响:任务的执行方式
并发:多个任务并发(同时)执行
串行:一个任务执行完毕后,再执行下一个任务
二、多线程方案
1. GCD
GCD源码:https://github.com/apple/swift-corelibs-libdispatch
同步/异步
GCD中有2个用来执行任务的函数
用同步的方式执行任务
dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);
用异步的方式执行任务
dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
队列
GCD的队列可以分为2大类型
并发队列(Concurrent Dispatch Queue)
- 可以让多个任务并发(同时)执行(自动开启多个线程同时执行任务)
- 并发功能只有在异步(dispatch_async)函数下才有效
串行队列(Serial Dispatch Queue)
- 让任务一个接着一个地执行(一个任务执行完毕后,再执行下一个任务)
各队列的执行效果
dispatch :派遣/调度
queue:队列
用来存放任务的先进先出(FIFO)的容器
sync:同步
只是在当前线程中执行任务,不具备开启新线程的能力
async:异步
可以在新的线程中执行任务,具备开启新线程的能力
concurrent:并发
多个任务并发(同时)执行
串行:
一个任务执行完毕后,再执行下一个任务
任务
- queue:队列
- block:任务
// 1.用同步的方式执行任务
dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);
// 2.用异步的方式执行任务
dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
// 3.GCD中还有个用来执行任务的函数
// 在前面的任务执行结束后它才执行,而且它后面的任务等它执行完成之后才会执行
dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block);
使用 GCD 死锁的情况
使用sync函数往当前串行队列中添加任务,会卡住当前的串行队列(产生死锁)
队列组
思考:如何用gcd实现以下功能
- 异步并发执行任务1、任务2
- 等任务1、任务2都执行完毕后,再回到主线程执行任务3
GCD 的其他用法
延时执行
dispatch_after(3.0, dispatch_get_main_queue(), ^{
/// 延时3秒执行的操作!
});
一次性执行
// 使用dispatch_once函数能保证某段代码在程序运行过程中只被执行1次
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
// 只执行1次的代码(这里面默认是线程安全的)
});
队列组
//创建调度组
dispatch_group_t group = dispatch_group_create();
//将调度组添加到队列,执行 block 任务
dispatch_group_async(group, queue, block);
//当调度组中的所有任务执行结束后,获得通知,统一做后续操作
dispatch_group_notify(group, dispatch_get_main_queue(), block);
GCD定时器
dispatch_source_t source = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER,0, 0, DISPATCH_TARGET_QUEUE_DEFAULT);
dispatch_source_set_event_handler(source, ^(){
NSLog(@"Time flies.");
});
dispatch_time_t start
dispatch_source_set_timer(source, DISPATCH_TIME_NOW, 5ull * NSEC_PER_SEC,100ull * NSEC_PER_MSEC);
self.source = source;
dispatch_resume(self.source);
2.NSOperation
略
3.NSThread
demo
- (void)testNSThread {
/// 获取当前线程
NSThread *currentThread = [NSThread currentThread];
/// 创建需要自己启动的线程
NSThread *creatThread = [[NSThread alloc] initWithTarget:self selector:@selector(runMethod) object:nil];
[creatThread start];
/// 创建自动启动的线程
[NSThread detachNewThreadSelector:@selector(runMethod2) toTarget:self withObject:nil];
}
- (void)runMethod {
NSLog(@"runMethod ++ %@",[NSThread currentThread]);
}
- (void)runMethod2 {
NSLog(@"runMethod2 ++ %@",[NSThread currentThread]);
}
相关 API
// 获取当前线程
+ (NSThread *)currentThread;
// 创建启动线程
+ (void)detachNewThreadSelector:(SEL)selector toTarget:(id)target withObject:(id)argument;
// 判断是否是多线程
+ (BOOL)isMultiThreaded;
// 线程休眠 NSDate 休眠到什么时候
+ (void)sleepUntilDate:(NSDate *)date;
// 线程休眠时间
+ (void)sleepForTimeInterval:(NSTimeInterval)ti;
// 结束/退出当前线程
+ (void)exit;
// 获取当前线程优先级
+ (double)threadPriority;
// 设置线程优先级 默认为0.5 取值范围为0.0 - 1.0
// 1.0优先级最高
// 设置优先级
+ (BOOL)setThreadPriority:(double)p;
// 获取指定线程的优先级
- (double)threadPriority NS_AVAILABLE(10_6, 4_0);
- (void)setThreadPriority:(double)p NS_AVAILABLE(10_6, 4_0);
// 设置线程的名字
- (void)setName:(NSString *)n NS_AVAILABLE(10_5, 2_0);
- (NSString *)name NS_AVAILABLE(10_5, 2_0);
// 判断指定的线程是否是 主线程
- (BOOL)isMainThread NS_AVAILABLE(10_5, 2_0);
// 判断当前线程是否是主线程
+ (BOOL)isMainThread NS_AVAILABLE(10_5, 2_0); // reports whether current thread is main
// 获取主线程
+ (NSThread *)mainThread NS_AVAILABLE(10_5, 2_0);
- (id)init NS_AVAILABLE(10_5, 2_0); // designated initializer
// 创建线程
- (id)initWithTarget:(id)target selector:(SEL)selector object:(id)argument NS_AVAILABLE(10_5, 2_0);
// 指定线程是否在执行
- (BOOL)isExecuting NS_AVAILABLE(10_5, 2_0);
// 线程是否完成
- (BOOL)isFinished NS_AVAILABLE(10_5, 2_0);
// 线程是否被取消 (是否给当前线程发过取消信号)
- (BOOL)isCancelled NS_AVAILABLE(10_5, 2_0);
// 发送线程取消信号的 最终线程是否结束 由 线程本身决定
- (void)cancel NS_AVAILABLE(10_5, 2_0);
// 启动线程
- (void)start NS_AVAILABLE(10_5, 2_0);
// 线程主函数 在线程中执行的函数 都要在-main函数中调用,自定义线程中重写-main方法
- (void)main NS_AVAILABLE(10_5, 2_0); // thread body metho
线程间通信
//在主线程上执行操作,例如给UIImageVIew设置图片
- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait
//在指定线程上执行操作
- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thread withObject:(id)arg waitUntilDone:(BOOL)wait
三、线程安全方案(锁)
多线程的安全隐患:一块资源可能会被多个线程共享,也就是多个线程可能会访问同一块资源
比如多个线程访问同一个对象、同一个变量、同一个文件
当多个线程访问同一块资源时,很容易引发数据错乱和数据安全问题
解决方案:使用线程同步技术(同步,就是协同步调,按预定的先后次序进行)。常见的线程同步技术是:加锁
1.iOS 中的线程同步方案
- OSSpinLock
- os_unfair_lock
- pthread_mutex
- dispatch_semaphore
- dispatch_queue(DISPATCH_QUEUE_SERIAL)
- NSLock
- NSRecursiveLock
- NSCondition
- NSConditionLock
- @synchronized
2.OSSpinLock
OSSpinLock叫做”自旋锁”,等待锁的线程会处于忙等(busy-wait)状态,一直占用着CPU资源。(目前已经不再安全,可能会出现优先级反转问题)
优先级:优先级低的线程先获取锁,而等待锁的线程优先级较高,它会一直占用着CPU资源,优先级低的线程可能一直无法获得时间片,进而无法释放锁
使用:
需要导入头文件#import <libkern/OSAtomic.h>
3.os_unfair_lock
os_unfair_lock 用于取代不安全的 OSSpinLock ,从 iOS10 开始才支持
从底层调用看,等待 os_unfair_lock 锁的线程会处于休眠状态,并非忙等
需要导入头文件#import <os/lock.h>
4.pthread_mutex
mutex叫做”互斥锁”,等待锁的线程会处于休眠状态
需要导入头文件#import <pthread.h>
pthread_mutex 递归锁实现
pthread_mutex 条件锁实现
demo
- (instancetype)init
{
if (self = [super init]) {
// 初始化属性
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
// 初始化锁
pthread_mutex_init(&_mutex, &attr);
// 销毁属性
pthread_mutexattr_destroy(&attr);
// 初始化条件
pthread_cond_init(&_cond, NULL);
self.data = [NSMutableArray array];
}
return self;
}
- (void)otherTest
{
[[[NSThread alloc] initWithTarget:self selector:@selector(__remove) object:nil] start];
[[[NSThread alloc] initWithTarget:self selector:@selector(__add) object:nil] start];
}
// 生产者-消费者模式
// 线程1
// 删除数组中的元素
- (void)__remove
{
pthread_mutex_lock(&_mutex);
NSLog(@"__remove - begin");
if (self.data.count == 0) {
// 等待
pthread_cond_wait(&_cond, &_mutex);
}
[self.data removeLastObject];
NSLog(@"删除了元素");
pthread_mutex_unlock(&_mutex);
}
// 线程2
// 往数组中添加元素
- (void)__add
{
pthread_mutex_lock(&_mutex);
sleep(1);
[self.data addObject:@"Test"];
NSLog(@"添加了元素");
// 信号
pthread_cond_signal(&_cond);
// 广播
// pthread_cond_broadcast(&_cond);
pthread_mutex_unlock(&_mutex);
}
- (void)dealloc
{
pthread_mutex_destroy(&_mutex);
pthread_cond_destroy(&_cond);
}
remove 方法先获得锁,这时 count ==0 触发等待(pthread_cond_wait),释放锁,add 方法得以执行,在条件满足时,调用 pthread_cond_signal 唤醒之前 wait 的线程。
pthread_cond_wait 的含义
- 当条件 &_cond 不满足时,释放锁;从而其他线程可以获得锁
- 当前线程休眠
- 当条件 &_cond 满足时,重新获得锁
适用场景:类似生产者-消费者模型
5.dispatch_semaphore
类似 NSOperationQueue 的 maxConcurrentOperationCount 的功能
demo
@interface SemaphoreDemo()
@property (strong, nonatomic) dispatch_semaphore_t semaphore;
@property (strong, nonatomic) dispatch_semaphore_t ticketSemaphore;
@property (strong, nonatomic) dispatch_semaphore_t moneySemaphore;
@end
@implementation SemaphoreDemo
- (instancetype)init
{
if (self = [super init]) {
self.semaphore = dispatch_semaphore_create(5);
self.ticketSemaphore = dispatch_semaphore_create(1);
self.moneySemaphore = dispatch_semaphore_create(1);
}
return self;
}
- (void)__drawMoney
{
dispatch_semaphore_wait(self.moneySemaphore, DISPATCH_TIME_FOREVER);
[super __drawMoney];
dispatch_semaphore_signal(self.moneySemaphore);
}
- (void)__saveMoney
{
dispatch_semaphore_wait(self.moneySemaphore, DISPATCH_TIME_FOREVER);
[super __saveMoney];
dispatch_semaphore_signal(self.moneySemaphore);
}
- (void)__saleTicket
{
dispatch_semaphore_wait(self.ticketSemaphore, DISPATCH_TIME_FOREVER);
[super __saleTicket];
dispatch_semaphore_signal(self.ticketSemaphore);
}
- (void)otherTest
{
for (int i = 0; i < 20; i++) {
[[[NSThread alloc] initWithTarget:self selector:@selector(test) object:nil] start];
}
}
// 线程10、7、6、9、8
- (void)test
{
// 如果信号量的值 > 0,就让信号量的值减1,然后继续往下执行代码
// 如果信号量的值 <= 0,就会休眠等待,直到信号量的值变成>0,就让信号量的值减1,然后继续往下执行代码
dispatch_semaphore_wait(self.semaphore, DISPATCH_TIME_FOREVER);
sleep(2);
NSLog(@"test - %@", [NSThread currentThread]);
// 让信号量的值+1
dispatch_semaphore_signal(self.semaphore);
}
@end
6.dispatch_queue(DISPATCH_QUEUE_SERIAL)
demo
@interface SerialQueueDemo()
@property (strong, nonatomic) dispatch_queue_t ticketQueue;
@property (strong, nonatomic) dispatch_queue_t moneyQueue;
@end
@implementation SerialQueueDemo
- (instancetype)init
{
if (self = [super init]) {
self.ticketQueue = dispatch_queue_create("ticketQueue", DISPATCH_QUEUE_SERIAL);
self.moneyQueue = dispatch_queue_create("moneyQueue", DISPATCH_QUEUE_SERIAL);
}
return self;
}
- (void)__drawMoney
{
dispatch_sync(self.moneyQueue, ^{
[super __drawMoney];
});
}
- (void)__saveMoney
{
dispatch_sync(self.moneyQueue, ^{
[super __saveMoney];
});
}
- (void)__saleTicket
{
dispatch_sync(self.ticketQueue, ^{
[super __saleTicket];
});
}
@end
使用技巧
#define SemaphoreBegin \
static dispatch_semaphore_t semaphore; \
static dispatch_once_t onceToken; \
dispatch_once(&onceToken, ^{ \
semaphore = dispatch_semaphore_create(1); \
}); \
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
#define SemaphoreEnd \
dispatch_semaphore_signal(semaphore);
- (void)test1
{
SemaphoreBegin;
// .....
SemaphoreEnd;
}
7.NSLock & NSRecursiveLock
NSLock 是对普通 mutex 锁的封装(互斥锁)
demo
- (void)testNSLock {
NSLock *lock = [[NSLock alloc] init];
[lock lock];
// 需要锁定的代码
[lock unlock];
}
8.NSCondition
demo
- (instancetype)init
{
if (self = [super init]) {
self.condition = [[NSCondition alloc] init];
self.data = [NSMutableArray array];
}
return self;
}
- (void)otherTest
{
[[[NSThread alloc] initWithTarget:self selector:@selector(__remove) object:nil] start];
[[[NSThread alloc] initWithTarget:self selector:@selector(__add) object:nil] start];
}
// 生产者-消费者模式
// 线程1
// 删除数组中的元素
- (void)__remove
{
[self.condition lock];
NSLog(@"__remove - begin");
if (self.data.count == 0) {
// 等待
[self.condition wait];
}
[self.data removeLastObject];
NSLog(@"删除了元素");
[self.condition unlock];
}
// 线程2
// 往数组中添加元素
- (void)__add
{
[self.condition lock];
sleep(1);
[self.data addObject:@"Test"];
NSLog(@"添加了元素");
// 信号
[self.condition signal];
// 广播
// [self.condition broadcast];
[self.condition unlock];
}
9.NSConditionLock
initWithCondition:(NSInteger)condition
- 初始化,并且设置条件锁内部存储的条件为 condition
- 如果直接 alloc init 创建,默认初始条件值为 0
lockWhenCondition:(NSInteger)condition 含义
- 当条件锁内部存储的条件是 condition 时才可以加锁
unlockWithCondition:(NSInteger)condition
- 解锁,同时设置内部存储的条件为2
lock
- 直接加锁,不去关心 condition
demo
@interface NSConditionLockDemo()
@property (strong, nonatomic) NSConditionLock *conditionLock;
@end
@implementation NSConditionLockDemo
- (instancetype)init
{
if (self = [super init]) {
self.conditionLock = [[NSConditionLock alloc] initWithCondition:1];
}
return self;
}
- (void)otherTest
{
[[[NSThread alloc] initWithTarget:self selector:@selector(__one) object:nil] start];
[[[NSThread alloc] initWithTarget:self selector:@selector(__two) object:nil] start];
[[[NSThread alloc] initWithTarget:self selector:@selector(__three) object:nil] start];
}
- (void)__one
{
[self.conditionLock lock];
NSLog(@"__one");
sleep(1);
[self.conditionLock unlockWithCondition:2];
}
- (void)__two
{
[self.conditionLock lockWhenCondition:2];
NSLog(@"__two");
sleep(1);
[self.conditionLock unlockWithCondition:3];
}
- (void)__three
{
[self.conditionLock lockWhenCondition:3];
NSLog(@"__three");
[self.conditionLock unlock];
}
@end
适用场景:处理多个线程间的依赖问题,实现线程间任务按指定顺序执行。
10.@synchronized
互斥锁:使用互斥锁,在同一个时间,只允许一条线程执行锁中的代码。因为互斥锁的代价非常昂贵,所以锁定的代码范围应该尽可能小,只要锁住资源读写部分的代码即可。使用互斥锁也会影响并发的目的。
@synchronized(锁对象) {
// 需要锁定的代码
}
11.atomic
OC在定义属性时有nonatomic和atomic两种选择。 atomic:原子属性,为setter方法加锁(默认就是atomic) nonatomic:非原子属性,不会为setter方法加锁。 atomic加锁原理:
@property (assign, atomic) int age;
- (void)setAge:(int)age
{
@synchronized(self) {
_age = age;
}
}
- atomic:线程安全,需要消耗大量的资源
- nonatomic:非线程安全,适合内存小的移动设备
iOS开发的建议:
(1)所有属性都声明为nonatomic
(2)尽量避免多线程抢夺同一块资源
(3)尽量将加锁、资源抢夺的业务逻辑交给服务器端处理,减小移动客户端的压力
多余容器对象(NSMutableArray等)进行 add/remove 操作不是线程安全的。
四、锁的性能比较
推荐使用 dispatch_semaphore 和 pthread_mutex
五、自旋锁与互斥锁比较
什么情况使用自旋锁比较划算?
- 预计线程等待锁的时间很短
- 加锁的代码(临界区)经常被调用,但竞争情况很少发生
- CPU资源不紧张
- 多核处理器
什么情况使用互斥锁比较划算?
- 预计线程等待锁的时间较长
- 单核处理器
- 临界区有IO操作
- 临界区代码复杂或者循环量大
- 临界区竞争非常激烈
六、读写安全(读写锁)
1.iOS中的读写安全方案
思考如何实现以下场景
- 同一时间,只能有1个线程进行写的操作
- 同一时间,允许有多个线程进行读的操作
- 同一时间,不允许既有写的操作,又有读的操作
上面的场景就是典型的“多读单写”,经常用于文件等数据的读写操作,iOS中的实现方案有
- pthread_rwlock:读写锁
- dispatch_barrier_async:异步栅栏调用
2.pthread_rwlock
demo
@interface ViewController ()
@property (assign, nonatomic) pthread_rwlock_t lock;
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
// 初始化锁
pthread_rwlock_init(&_lock, NULL);
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
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);
NSLog(@"%s", __func__);
pthread_rwlock_unlock(&_lock);
}
- (void)write
{
pthread_rwlock_wrlock(&_lock);
sleep(1);
NSLog(@"%s", __func__);
pthread_rwlock_unlock(&_lock);
}
- (void)dealloc
{
pthread_rwlock_destroy(&_lock);
}
@end
3.dispatch_barrier_async
在 dispatch_barrier_async 执行任务时,绝对不允许有其他任务在执行。
面试题
1.你理解的多线程?
2.iOS的多线程方案有哪几种?你更倾向于哪一种?
3.你在项目中用过 GCD 吗?
4.GCD 的队列类型
5.说一下 OperationQueue 和 GCD 的区别,以及各自的优势
6.线程安全的处理手段有哪些?
7.OC你了解的锁有哪些?在你回答基础上进行二次提问;
追问一:自旋和互斥对比?
追问二:使用以上锁需要注意哪些?
追问三:用C/OC/C++,任选其一,实现自旋或互斥?口述即可!