iOS - 多线程

Cross-D

已于 2023-03-23 13:37:08 修改

阅读量411

点赞数

分类专栏： iOS底层原理文章标签： ios objective-c xcode

于 2020-10-02 20:58:39 首次发布

本文链接：https://blog.youkuaiyun.com/c_zzjsdmj/article/details/108497886

版权

iOS底层原理专栏收录该内容

7 篇文章

订阅专栏

概念

进程：正在进行的程序，我们就叫它进程。
线程：线程就是进程中的一个独立的执行路径。每一个程序中至少包含一条线程，这条线程，我们叫它主线程。
多线程：多线程也就是说一个程序中有多条执行路径。在iOS当中将一些比较耗时的操作放到另一条执行路径里。让它与主线程同时运行.这样不会造成主线程的堵塞。

任务：分为同步任务与异步任务，它们的区别是：

同步任务优先级高，在线程中有执行顺序，不会开启新的线程。
异步任务优先级低，在线程中执行没有顺序，看cpu闲不闲。在主队列中不会开启新的线程，其他队列会开启新的线程。

队列：队列我们可以把它理解为是管理任务的，它里面放着很多的任务，来管理这些任务什么时候在哪些线程里面执行（队列是先进先出的）。

串行队列：队列中的任务按顺序执行（不会同时执行）
并行队列：队列中的任务会并发执行，可能会有一个疑问，队列不是先进先出吗，如果后面的任务执行完了，怎么出去的了。这里需要强调下，任务执行完毕了，不一定出队列。只有前面的任务执行完了，才会出队列。

多线程

同步和异步主要影响：能不能开启新的线程
同步：在当前线程中执行任务，不具备开启新线程的能力
异步：在新的线程中执行任务，具备开启新线程的能力

并发和串行主要影响：任务的执行方式
并发：多个任务并发（同时）执行
串行：一个任务执行完毕后，再执行下一个任务

同步的话是立即执行、异步的话是等待执行完后执行，不抢占资源
异步串行队列，只生成一条线程，异步并行队列，每次都会生成一条线程

在这里插入图片描述

多线程安全隐患

解决方案：使用线程同步技术（同步，就是协同步调，按预定的先后次序进行）
常见的线程同步技术是：加锁（性能从高到低）

os_unfair_lock
OSSpinLock
dispatch_semaphore
pthread_mutex
dispatch_queue(DISPATCH_QUEUE_SERIAL)
NSLock
NSCondition
pthread_mutex(recursive)
NSRecursiveLock
NSConditionLock
@synchronized （互斥锁）

OSSpinLock

OSSpinLock叫做“自旋锁”，等待锁的线程会处于忙等（busy-wait）的状态，一直占用CPU资源
目前已经不再安全，可能会出现优先级反转问题
如果等待锁的线程优先级较高，它会一直占用着CPU资源，优先级低的线程就无法释放锁

//初始化
OSSpinLock lock = OS_SPINLOCK_INIT;
//尝试枷锁（如果需要等待就不加锁，直接返回false;如果需要等待就加锁，返回true）
bool result = OSSpinLockTry(&lock);
//加锁
OSSpinLockLock(&lock);
//解锁
OSSpinLockUnlock(&lock);

os_unfair_lock

os_unfair_lock用于取代不安全的OSSpinLock，从iOS10开始才支持
从底层调用看，等待os_unfair_lock锁的线程会处于休眠状态，并非忙等
需要导入头文件#import <os/lock.h>

//初始化
os_unfair_lock lock = OS_UNFAIR_LOCK_INIT;
//尝试枷锁
os_unfair_lock_trylock(&lock);
//加锁
os_unfair_lock_lock(&lock);
//解锁
os_unfair_lock_unlock(&lock);

dispatch_semaphore

semaphore叫做“信号量”
信号量的初始值可以用来控制线程并发访问的最大数量
信号量的初始值为1，代表同时只允许1条线程访问资源，保证线程同步

//信号量的初始值
int value = 1;
//初始化信号量
dispatch_semaphore_t semaphore = dispatch_semaphore_create(value);
//如果信号箱的值<=0，当前线程就会进入休眠等待（直到信号量的值>0）
//如果信号量的值>0，就减1，然后往下执行后面的代码
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
//让信号量的值加1
dispatch_semaphore_signal(semaphore);

GCD 栅栏函数

dispatch_barrier_async

这个函数传入的并发对了必须是自己通过dispatch_queue_create创建的
如果传入的是一个串行或是一个全局的并发队列，那这个函数便等同于dispatch_async函数的效果

//初始化队列
dispatch_queue_t queue = dispatch_queue_create("", DISPATCH_QUEUE_CONCURRENT);
//读
dispatch_async(queue, ^{});
//写
dispatch_barrier_async(queue, ^{});

dispatch_barrier_sync

这个函数传入的并发对了必须是自己通过dispatch_queue_create创建的
如果传入的是一个串行或是一个全局的并发队列，那这个函数便等同于dispatch_sync函数的效果

//初始化队列
dispatch_queue_t queue = dispatch_queue_create("", DISPATCH_QUEUE_CONCURRENT);
//写
dispatch_barrier_sync(queue, ^{});

pthread_mutex

mutex叫做“互斥锁”，等待锁的线程会处于休眠状态

//初始化锁的属性
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHEAD_MUTEX_NORMAL);
//初始化锁
pthread_mutex_t mutex;
pthread_mutex_init(&mutex, &attr);
//初始化条件
pthread_cond_t condition;
pthread_cond_init(&condition, NULL);
//等待条件（进入休眠，放开mutex锁，被唤醒后，会再次对mutex加锁）- (例如：数组增删条件)
pthread_cond_wait(&condition, &mutex);
//激活一个等待该条件的线程
pthread_cond_signal(&condition);
//激活所有等待该条件的线程
pthread_cond_broadcast(&condition);
//尝试加锁
pthread_mutex_trylock(&mutex);
//加锁
pthread_mutex_lock(&mutex);
//解锁
pthread_mutex_unlock(&mutex);
//销毁相关资源
pthread_mutexattr_destroy(&attr);
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&condition);

自旋锁、互斥锁比较

什么情况使用自旋锁比较划算？
1.预计线程等待锁的时间很短
2.加锁的代码（临界区）经常被调用，但竞争情况很少发生
3.CPU资源不紧张
4.多核处理器

什么情况使用互斥锁比较划算？
1.预计线程等待锁的时间较长
2.单核处理器
3.临界区有IO操作
4.临界区代码复杂或者循环量大
5.临界区竞争非常激烈

属性修饰词

nonatomic：非原子性
atomic：原子性（保证属性的setter/getter都是原子性操作，也就是保证setter和getter内部是线程同步的）

CADisplayLink、NSTimer使用注意

CADisplayLink、NSTimer会对target产生强引用，如果target又对她们产生强引用，那么会产生循环引用

解决方案

1、使用block
__weak typeof(self) weakSelf = self;
self.timer = [NSTimer scheDuledTimerWithTimeInterval:2.0 repeats:YES block:^(NSTimer *_Nonnull timer){
[weakself test];}]
2、使用代理对象（NSProxy - 只做消息转发，没有通过isa指针找方法）
+ (instancetype)proxyWithTarget:(id)target
{
CJTimerProxy *proxy = [self class];
proxy.target = target;
return proxy;
}
- (void)forwardInvocation:(NSInvocation *)anInvocation
{
[anInvocation invocationWithTarget:self.target];
}
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector
{
return [self.target methodSignatureForSelector:aSelector];
}

CJTimerProxy *proxy = [CJTimerProxy proxyWithTarget:self];
self.timer = [NSTimer scheDuledTimerWithTimeInterval:2.0 target:proxy selector:@selector(test) userInfo:nil YES];

GCD定时器

NSTimer依赖于Runloop，如果Runloop的任务繁重，可能会导致NSTimer不准时
而GCD的定时器会更加准时

dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
dispatch_source_set_timer(timer, DISPATCH_TIME_NOW, intervalInSeconds * NSEC_PER_SEC, 0 * NSEC_PER_SEC);
// 设置回调
dispatch_source_set_event_handler(timer, ^{
});
// 启动定时器
dispatch_resume(timer);