常用的多线程
| 技术方案 | 简介 | 语言 | 线程生命周期 | 使用频率 |
|---|---|---|---|---|
| pthread | 一套通用的多线程API，适用于Unix\Linux\Windows等系统，跨平台\可移植，使用难度大 | C | 程序员管理 | 几乎不用 |
| NSThread | 使用更加面向对象，简单易用，可直接操作线程对象 | OC | 程序员管理 | 偶尔使用 |
| GCD | 旨在替代NSThread等线程技术，充分利用设备的多核 | C | 自动管理 | 经常使用 |
| NSOperation | 基于GCD（底层是GCD），比GCD多了一些更简单实用的功能，使用更加面向对象 | OC | 自动管理 | 经常使用 |
GCD
GCD中有2个用来执行任务的函数
用同步的方式执行任务
dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);
- queue：队列
- block：任务
用异步的方式执行任务
dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
GCD的队列可以分为2大类型
并发队列（Concurrent Dispatch Queue）可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）并发功能只有在异步（dispatch_async）函数下才有效
串行队列（Serial Dispatch Queue）
让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）
有4个术语比较容易混淆：同步、异步、并发、串行
同步和异步主要影响：能不能开启新的线程
同步：在当前线程中执行任务，不具备开启新线程的能力
异步：在新的线程中执行任务，具备开启新线程的能力并发和串行主要影响：任务的执行方式
并发：多个任务并发（同时）执行
串行：一个任务执行完毕后，再执行下一个任务
- (void)testOne
{
// 问题：以下代码是在主线程执行的，会不会产生死锁？会！
NSLog(@"执行任务1");
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_sync(queue, ^{
//等待testOne结束，无法结束导致
NSLog(@"执行任务2");
});
NSLog(@"执行任务3");
// dispatch_sync立马在当前线程同步执行任务
}
- (void)testTwo
{
// 问题：以下代码是在主线程执行的，会不会产生死锁？不会！
NSLog(@"执行任务1");
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_async(queue, ^{
NSLog(@"执行任务2");
});
NSLog(@"执行任务3");
// dispatch_async不要求立马在当前线程同步执行任务，等待testTwo执行结束，才会执行异步线程
}
- (void)testThird
{
// 问题：以下代码是在主线程执行的，会不会产生死锁？会！
NSLog(@"执行任务1");
dispatch_queue_t queue = dispatch_queue_create("myqueu", DISPATCH_QUEUE_SERIAL);
dispatch_async(queue, ^{ // 0
NSLog(@"执行任务2");
dispatch_sync(queue, ^{ // 1
NSLog(@"执行任务3");
});
NSLog(@"执行任务4");
});
NSLog(@"执行任务5");
//和主线程的执行类似，会卡死等待上一个任务testThird 的结束，只要在同一个串行队列添加同步线程就会死锁，无论外面是否包裹了异步线程
}
- (void)testFour
{
// 问题：以下代码是在主线程执行的，会不会产生死锁？不会！
NSLog(@"执行任务1");
dispatch_queue_t queue = dispatch_queue_create("myqueu", DISPATCH_QUEUE_SERIAL);
// dispatch_queue_t queue2 = dispatch_queue_create("myqueu2", DISPATCH_QUEUE_CONCURRENT);
dispatch_queue_t queue2 = dispatch_queue_create("myqueu2", DISPATCH_QUEUE_SERIAL);
dispatch_async(queue, ^{ // 0
NSLog(@"执行任务2");
dispatch_sync(queue2, ^{ // 1
NSLog(@"执行任务3");
});
NSLog(@"执行任务4");
});
NSLog(@"执行任务5");
//添加在不同的队列里面，所以即使是串行队列的同步也没有关系
}
- (void)testFive
{
// 问题：以下代码是在主线程执行的，会不会产生死锁？不会！
NSLog(@"执行任务1");
dispatch_queue_t queue = dispatch_queue_create("myqueu", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{ // 0
NSLog(@"执行任务2");
dispatch_sync(queue, ^{ // 1
NSLog(@"执行任务3");
});
NSLog(@"执行任务4");
});
NSLog(@"执行任务5");
//并发队列可以执行多个任务，所以不会阻塞
}
performSelector:withObject:afterDelay:的本质是往Runloop中添加定时器，子线程默认没有启动Runloop
performSelector: withObject:的本质是在RunTime中，相当于objc_msgend方法
- (void)test
{
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
dispatch_async(queue, ^{
NSLog(@"1");
// 这句代码的本质是往Runloop中添加定时器
[self performSelector:@selector(test) withObject:nil afterDelay:.0];
NSLog(@"3");
// [[NSRunLoop currentRunLoop] addPort:[[NSPort alloc] init] forMode:NSDefaultRunLoopMode];
[[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
});
}
Group
- (void)test {
// 创建队列组
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]);
}
});
// 等前面的任务执行完毕后，会自动执行这个任务
// dispatch_group_notify(group, queue, ^{
// dispatch_async(dispatch_get_main_queue(), ^{
// for (int i = 0; i < 5; i++) {
// NSLog(@"任务3-%@", [NSThread currentThread]);
// }
// });
// });
// dispatch_group_notify(group, dispatch_get_main_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(@"任务3-%@", [NSThread currentThread]);
}
});
dispatch_group_notify(group, queue, ^{
for (int i = 0; i < 5; i++) {
NSLog(@"任务4-%@", [NSThread currentThread]);
}
});
}
安全隐患
资源共享 1块资源可能会被多个线程共享，也就是多个线程可能会访问同一块资源，比如多个线程访问同一个对象、同一个变量、同一个文件
当多个线程访问同一块资源时，很容易引发数据错乱和数据安全问题
解决方案：使用线程同步技术（同步，就是协同步调，按预定的先后次序进行），常见的线程同步技术是：
OSSpinLock
OSSpinLock叫做”自旋锁”，等待锁的线程会处于忙等（busy-wait）状态，一直占用着CPU资源，目前已经不再安全，可能会出现优先级反转问题，如果等待锁的线程优先级较高，它会一直占用着CPU资源，优先级低的线程就无法释放锁，需要导入头文件#import
可以通过尝试加锁及解决线程阻塞
if (OSSpinLockTry(&_lock)) {
int oldTicketsCount = self.ticketsCount;
sleep(.2);
oldTicketsCount--;
self.ticketsCount = oldTicketsCount;
NSLog(@"还剩%d张票 - %@", oldTicketsCount, [NSThread currentThread]);
OSSpinLockUnlock(&_lock);
}
os_unfair_lock
os_unfair_lock用于取代不安全的OSSpinLock ，从iOS10开始才支持，从底层调用看，等待os_unfair_lock锁的线程会处于休眠状态，并非忙等，需要导入头文件#import
pthread_mutex
mutex叫做”互斥锁”，等待锁的线程会处于休眠状态，需要导入头文件#import
-
mutex根据属性不同，还有一个递归锁，是允许同一个线程递归，如果是两个线程同时调一个方法，第二个线程会等待
pthread_mutex.png
汇编中调用sysCall之后唤起模拟器，线程休眠了
pthread_mutex 条件
NSLock、NSRecursiveLock
NSLock是对mutex普通锁的封装
NSRecursiveLock也是对mutex递归锁的封装，API跟NSLock基本一致
NSCondition
NSCondition是对mutex和cond的封装
NSConditionLock
NSConditionLock是对NSCondition的进一步封装，可以设置具体的条件值
dispatch_semaphore
semaphore叫做”信号量”，信号量的初始值，可以用来控制线程并发访问的最大数量，信号量的初始值为1，代表同时只允许1条线程访问资源，保证线程同步
dispatch_queue(DISPATCH_QUEUE_SERIAL)
直接使用GCD的串行队列，也是可以实现线程同步的
@synchronized
@synchronized是对mutex递归锁的封装
@synchronized(obj)内部会生成obj对应的递归锁，然后进行加锁、解锁操作
源码查看：objc4中的objc-sync.mm文件
性能比较
性能从高到低排序
- os_unfair_lock
- OSSpinLock
- dispatch_semaphore
- pthread_mutex
- dispatch_queue(DISPATCH_QUEUE_SERIAL)
- NSLock
- NSCondition
- pthread_mutex(recursive)
- NSRecursiveLock
- NSConditionLock
- @synchronized
使用场景
什么情况使用自旋锁比较划算？
- 预计线程等待锁的时间很短
- 加锁的代码（临界区）经常被调用，但竞争情况很少发生
- CPU资源不紧张
- 多核处理器
什么情况使用互斥锁比较划算？
- 预计线程等待锁的时间较长
- 单核处理器
- 临界区有IO操作
- 临界区代码复杂或者循环量大
- 临界区竞争非常激烈
atomic
atomic用于保证属性setter、getter的原子性操作，相当于在getter和setter内部加了线程同步的锁，可以参考源码objc4的objc-accessors.mm，
iOS中的读写安全方案
思考如何实现以下场景
同一时间，只能有1个线程进行写的操作
同一时间，允许有多个线程进行读的操作
同一时间，不允许既有写的操作，又有读的操作
上面的场景就是典型的“多读单写”，经常用于文件等数据的读写操作，iOS中的实现方案有
pthread_rwlock：读写锁
dispatch_barrier_async：异步栅栏调用
pthread_rwlock
等待锁的线程会进入休眠
dispatch_barrier_async
这个函数传入的并发队列必须是自己通过dispatch_queue_cretate创建的
如果传入的是一个串行或是一个全局的并发队列，那这个函数便等同于dispatch_async函数的效果