2024年iOS的多线程安全隐患与线程同步方案

1、NSCondition是对条件锁（mutex和cond）的封装。

2、NSConditionLock是对NSCondition的进一步封装，可以设置具体的条件值

@interface Demo()

@property (strong, nonatomic) NSConditionLock *conditionLock;

@end



@implementation Demo

- (instancetype)init {

    if (self = [super init]) {

        self.conditionLock = [[NSConditionLock alloc] initWithCondition:1];

    }

    return self;

}



- (void)test {

		// 1、当首个加锁触发没有添加条件时，那么在初始化的时候，不管设置什么条件，都能正常执行

    [self.conditionLock lock];

    // 2、如果有加条件，那么必须跟设置的条件匹配

    // [self.conditionLock lockWhenCondition:1];

    

    NSLog(@"test");

    sleep(1);

    

    [self.conditionLock unlockWithCondition:2];

}

@end

2.4、dispatch_semaphore 信号量

---

1、semaphore叫做”信号量”。

2、信号量的初始值，可以用来控制线程并发访问的最大数量。

3、信号量的初始值为1，代表同时只允许1条线程访问资源，保证线程同步。

		// 信号量初始值

    int value = 5;

    // 初始化信号量

    dispatch_semaphore_t semaphore = dispatch_semaphore_create(value);

    /**

     * 1、如果信号量的值 > 0，就让信号量的值减1，然后继续往下执行代码

     * 2、如果信号量的值 <= 0，就会休眠等待，直到信号量的值变成 > 0，就让信号量的值减1，然后继续往下执行代码

     */

    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);



    // 让信号量的值加1

    dispatch_semaphore_signal(semaphore);

2.4、dispatch_queue

---

直接使用GCD的串行队列，也是可以实现线程同步。

@interface Demo()

@property (strong, nonatomic) dispatch_queue_t myQueue;

@end



@implementation Demo

- (instancetype)init {

    if (self = [super init]) {

        self.myQueue = dispatch_queue_create("myQueue", DISPATCH_QUEUE_SERIAL);

    }

    return self;

}

- (void)test1 {

    dispatch_sync(self.myQueue, ^{

        NSLog(@"%s",__func__);

    });

}



- (void)test2 {

    dispatch_sync(self.myQueue, ^{

        NSLog(@"%s",__func__);

    });

}

@end

2.5、@synchronized（不推荐）

---

1、@synchronized是对mutex递归锁的封装。

2、源码查看：objc4中的objc-sync.mm文件。

3、@synchronized(obj)内部会生成obj对应的递归锁，然后进行加锁、解锁操作。

2.6、atomic 原子性（不推荐）

---

1、atomic用于保证属性setter、getter的原子性操作，相当于在getter和setter内部加了线程同步的锁。

2、可以参考源码objc4的objc-accessors.mm。

3、不能保证使用属性的过程是线程安全的。

2.7、读写安全

---

场景：

1、同一时间，只能有1个线程进行写的操作

2、同一时间，允许有多个线程进行读的操作

3、同一时间，不允许既有写的操作，又有读的操作

上面的场景就是典型的 “多读单写”，经常用于文件等数据的读写操作，iOS中的实现方案有：

1、pthread_rwlock：读写锁

2、dispatch_barrier_async：异步栅栏调用

2.7.1、pthread_rwlock_t - 读写锁

读写锁：是计算机程序并发控制的一种同步机制，用于解决读写问题。

读写锁允许并行读、串行写。与互斥锁的一次只有一个线程执行操作相比，性能更高。比如构建缓存系统，将网络资源写入缓存，后期从缓存读取资源。缓存系统必须线程安全，允许并行读取，串行写入（又称多读单写）。

    // 初始化锁

    pthread_rwlock_t lock;

    pthread_rwlock_init(&lock, NULL);

    

    // 读 - 加锁

    pthread_rwlock_rdlock(&lock);

    // 读 - 尝试加锁

    pthread_rwlock_tryrdlock(&lock);

    



    // 写 - 加锁

    pthread_rwlock_wrlock(&lock);

    // 写 - 尝试加锁

    pthread_rwlock_trywrlock(&lock);

    

    // 解锁

    pthread_rwlock_unlock(&lock);

    // 毁锁

    pthread_rwlock_destroy(&lock);

2.7.2、dispatch barrier - 异步栅栏

在保护临界区域时，GCD 提供了 dispatch barrier。当执行 barrier 任务时，队列中所有其他任务都会等待。没有执行 barrier 任务时，其他任务并行执行。

代码示例：

#import "ViewController.h"

#import <pthread.h>



@interface ViewController ()

@property (strong, nonatomic) dispatch_queue_t queue;

@end



@implementation ViewController



- (void)viewDidLoad {

    [super viewDidLoad];

    /**

    * 1、必须是自己通过dispatch_queue_cretate创建的

    * 2、如果传入的是串行或全局的并发队列，那这个函数便等同于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 read];

        });

        

        dispatch_async(self.queue, ^{

            [self read];

        });

        

        dispatch_barrier_async(self.queue, ^{

            [self write];

        });

    }

}



- (void)read {

    sleep(1);

    NSLog(@"read");

}



- (void)write {

    sleep(1);

    NSLog(@"write");

}



@end

3、线程同步方案性能比较

===============================================================================

性能从高到低排序：

os_unfair_lock：官方自旋锁的替代方案

OSSpinLock：自旋锁，不安全，官方不推荐使用

dispatch_semaphore：信号量

pthread_mutex：mutex普通锁、条件锁

dispatch_queue(DISPATCH_QUEUE_SERIAL)：GCD串行队列实现同步

NSLock：mutex普通锁的OC封装

NSCondition：mutex条件锁的OC封装

pthread_mutex(recursive)：mutex递归锁，逻辑相对复杂，所以性能相对比较低

NSRecursiveLock：递归锁的OC封装

NSConditionLock：条件锁NSCondition的进一步封装

@synchronized：mutex递归锁的封装，性能最低，一般在mac应用中使用。

4、问答拓展

=========================================================================

4.1、GNUstep

---

1、GNU计划的项目之一，它将Cocoa的OC库重新开源实现了一遍。

2、虽然不是苹果官方源码，但还是具有一定的参考价值。

3、源码地址：http://www.gnustep.org/resources/downloads.php

4.2、线程安全的处理手段有哪些？

---

使用线程同步技术：加锁。

4.3、OC你了解的锁有哪些？

---

在你回答基础上进行二次提问；

4.3.1、自旋和互斥对比？

1.1、什么情况使用自旋锁比较划算？

1、预计线程等待锁的时间很短

2、加锁的代码（临界区）经常被调用，但竞争情况很少发生

3、CPU资源不紧张

4、多核处理器

1.2、什么情况使用互斥锁比较划算？

1、预计线程等待锁的时间较长

1、临界区有IO操作

3、临界区代码复杂或者循环量大、临界区竞争非常激烈

4、单核处理器

4.3.2、使用以上锁需要注意哪些？

4.3.3、用C/OC/C++，任选其一，实现自旋或互斥？口述即可！

---

**🏆结束语🏆 **

💖如果觉得这篇内容能给您带来一点版主，欢迎点赞👍+收藏⭐️+评论📝支持一下博主哦🤞

本人从事网路安全工作12年，曾在2个大厂工作过，安全服务、售后服务、售前、攻防比赛、安全讲师、销售经理等职位都做过，对这个行业了解比较全面。

最近遍览了各种网络安全类的文章，内容参差不齐，其中不伐有大佬倾力教学，也有各种不良机构浑水摸鱼，在收到几条私信，发现大家对一套完整的系统的网络安全从学习路线到学习资料，甚至是工具有着不小的需求。

最后，我将这部分内容融会贯通成了一套282G的网络安全资料包，所有类目条理清晰，知识点层层递进，需要的小伙伴可以点击下方小卡片领取哦！下面就开始进入正题，如何从一个萌新一步一步进入网络安全行业。

学习路线图

其中最为瞩目也是最为基础的就是网络安全学习路线图，这里我给大家分享一份打磨了3个月，已经更新到4.0版本的网络安全学习路线图。

相比起繁琐的文字，还是生动的视频教程更加适合零基础的同学们学习，这里也是整理了一份与上述学习路线一一对应的网络安全视频教程。

网络安全工具箱

当然，当你入门之后，仅仅是视频教程已经不能满足你的需求了，你肯定需要学习各种工具的使用以及大量的实战项目，这里也分享一份我自己整理的网络安全入门工具以及使用教程和实战。

项目实战

最后就是项目实战，这里带来的是SRC资料&HW资料，毕竟实战是检验真理的唯一标准嘛~

面试题

归根结底，我们的最终目的都是为了就业，所以这份结合了多位朋友的亲身经验打磨的面试题合集你绝对不能错过！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以点击这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！