美文网首页iOS技术及开发讨论
iOS关于线程加锁方案

iOS关于线程加锁方案

作者: 扶摇先生 | 来源:发表于2021-05-07 18:08 被阅读0次

从前的锁也好看
钥匙精美有样子
你锁了 人家就懂了

一、存在的问题

1、实例

@interface TSDController ()

@property(nonatomic, assign) int totalMoney;

@end

@implementation TSDController

- (void)viewDidLoad {
    [super viewDidLoad];
    self.totalMoney = 200;
    [self earnAndCostMoney];
    // Do any additional setup after loading the view.
}
- (void)earnAndCostMoney {
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
     
     dispatch_async(queue, ^{
         for (int i = 0; i < 5; i++) {
             [self earnMoney];
         }
     });
     
     dispatch_async(queue, ^{
         for (int i = 0; i < 5; i++) {
             [self costMoney];
         }
     });
}
- (void)earnMoney {
    int oldMoney = self.totalMoney;
    sleep(0.3);
    oldMoney += 40;
    self.totalMoney = oldMoney;
    NSLog(@"挣40元，余额%d元---%@", self.totalMoney, [NSThread currentThread]);
}
- (void)costMoney {
    int oldMoney = self.totalMoney;
    sleep(0.3);
    oldMoney -= 20;
    self.totalMoney = oldMoney;
    NSLog(@"花20元，余额%d元---%@", self.totalMoney, [NSThread currentThread]);
}

打印结果（最后余额应该是300的，出问题的结果不一定，此次是320）：

花20元，余额180元---<NSThread: 0x60000002ff40>{number = 5, name = (null)}
挣40元，余额220元---<NSThread: 0x60000005e680>{number = 6, name = (null)}
花20元，余额200元---<NSThread: 0x60000002ff40>{number = 5, name = (null)}
花20元，余额180元---<NSThread: 0x60000002ff40>{number = 5, name = (null)}
挣40元，余额240元---<NSThread: 0x60000005e680>{number = 6, name = (null)}
挣40元，余额260元---<NSThread: 0x60000005e680>{number = 6, name = (null)}
花20元，余额220元---<NSThread: 0x60000002ff40>{number = 5, name = (null)}
挣40元，余额300元---<NSThread: 0x60000005e680>{number = 6, name = (null)}
花20元，余额280元---<NSThread: 0x60000002ff40>{number = 5, name = (null)}
挣40元，余额320元---<NSThread: 0x60000005e680>{number = 6, name = (null)}

2、图解

1、存在问题的结果.png
2、我们希望的结果.png
由上图以及代码可知，在多个线程同时对同一个对象做处理的时候，有可能出现，多个任务在同一时间，没有先后顺序的对同一个对象进行读或写的操作，这样的话，就会出现上面的问题，而解决这一问题的办法就是线程同步方案（线程锁）

二、线程同步方案（线程锁）

1、OSSPinLock: 自旋锁， 性能很高，但是不推荐使用.

导入头文件：#import <libkern/OSAtomic.h>
创建锁：
@property (assign, nonatomic) OSSpinLock lock;
// 初始化锁
self.lock = OS_SPINLOCK_INIT;
加锁：OSSpinLockLock（&_lock）；
添加关键代码<><><>
解锁：OSSPinLockUnLock（&_lock）
注意： lock 要做成 全局变量，要使用同一锁才可以。如果有两个方法：判断两个方法 是否能同时执行（读写操作），如果需要这两个方法不能同时执行（读写操作） 则需要共用一把锁。
原理：第二条线程 会等待 （此时会存在线程等待）第一条线程解锁，才会继续执行。
p.s.OSSpinLock 的线程等待会处于忙等状态 （while（1）；）会一直占有CPU 的资源 并没有睡觉 休息。 目前此 锁已经不安全了 会出现问题：线程优先级反转问题。ios10 以后使用会警告️。

- (void)earnMoney {
    OSSpinLockLock(&_lock);
    int oldMoney = self.totalMoney;
    sleep(0.3);
    oldMoney += 40;
    self.totalMoney = oldMoney;
    NSLog(@"挣40元，余额%d元---%@", self.totalMoney, [NSThread currentThread]);
    OSSpinLockUnlock(&_lock);
}
- (void)costMoney {
    OSSpinLockLock(&_lock);
    int oldMoney = self.totalMoney;
    sleep(0.3);
    oldMoney -= 20;
    self.totalMoney = oldMoney;
    NSLog(@"花20元，余额%d元---%@", self.totalMoney, [NSThread currentThread]);
    OSSpinLockUnlock(&_lock);
}

打印结果：

挣40元，余额240元---<NSThread: 0x60000307a0c0>{number = 6, name = (null)}
挣40元，余额280元---<NSThread: 0x60000307a0c0>{number = 6, name = (null)}
挣40元，余额320元---<NSThread: 0x60000307a0c0>{number = 6, name = (null)}
挣40元，余额360元---<NSThread: 0x60000307a0c0>{number = 6, name = (null)}
挣40元，余额400元---<NSThread: 0x60000307a0c0>{number = 6, name = (null)}
花20元，余额380元---<NSThread: 0x60000307a0c0>{number = 6, name = (null)}
花20元，余额360元---<NSThread: 0x60000307a0c0>{number = 6, name = (null)}
花20元，余额340元---<NSThread: 0x60000307a0c0>{number = 6, name = (null)}
花20元，余额320元---<NSThread: 0x60000307a0c0>{number = 6, name = (null)}
花20元，余额300元---<NSThread: 0x60000307a0c0>{number = 6, name = (null)}

2. os_unfair_lock 现在它代替 OSSpinLock iOS 10 以后系统使用

导入头文件：import<os/lcok.h>
注意：os_unfair_lock 是一个C语言的结构体，如果要使用属性调用需要使用assign修饰，从iOS10开始支持，用于取代不安全的OSSpinLock
// Low-level lock的特点等不到锁就休眠
@property (assign, nonatomic) os_unfair_lock moneyLock;
使用方法：初始化、加锁、解锁
写法：

- (void)earnMoney {
    os_unfair_lock_lock(&_lock);
    int oldMoney = self.totalMoney;
    sleep(0.3);
    oldMoney += 40;
    self.totalMoney = oldMoney;
    NSLog(@"挣40元，余额%d元---%@", self.totalMoney, [NSThread currentThread]);
    os_unfair_lock_unlock(&_lock);
}
- (void)costMoney {
    os_unfair_lock_lock(&_lock);
    int oldMoney = self.totalMoney;
    sleep(0.3);
    oldMoney -= 20;
    self.totalMoney = oldMoney;
    NSLog(@"花20元，余额%d元---%@", self.totalMoney, [NSThread currentThread]);
    os_unfair_lock_unlock(&_lock);
}

打印log和OSSPinLock一样，注意：1、如果忘记解锁，os_unfair_lock的线程会一直处于等待，出现线程死锁现象。2、如果iOS 10 以下版本使用，会出现闪退现象

3、pthread_mutex :多平台通用，跨平台：互斥锁。等待锁的线程或处于休眠状态。区别于 自旋锁（OSSpinLock），自旋锁不会使线程休眠.

使用方式：导入头文件：#import<pthread.h>
静态初始化：pthread_mutex mutex = PTHREAD_MUTEX_INITIALIZER
但是不能直接 赋值给类属性，因为 PTHREAD_MUTEX_INITIALIZER 是一个结构体。
当设置type为 PTHREAD_MUTEX_NORMAL为互斥锁，当设置为PTHREAD_MUTEX_RECURSIVE时，为递归锁
@property (assign, nonatomic) pthread_mutex_t mutex;
动态初始化方式：

互斥锁

       // 初始化属性
       pthread_mutexattr_t attr;
       pthread_mutexattr_init(&attr);
       pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL); // normal
       // 初始化锁
       pthread_mutex_init(&_mutex, &attr);
       // 销毁属性
       pthread_mutexattr_destroy(&attr);

注意： 这里的属性设置pthread_mutex_init(&ticketMutex, NULL); 可以传NULL，默认就等同于：PTHREAD_MUTEX_DEFAULT

- (void)earnMoney {
    pthread_mutex_lock(&_mutex);
    int oldMoney = self.totalMoney;
    sleep(0.3);
    oldMoney += 40;
    self.totalMoney = oldMoney;
    NSLog(@"挣40元，余额%d元---%@", self.totalMoney, [NSThread currentThread]);
    pthread_mutex_unlock(&_mutex);
}
- (void)costMoney {
    pthread_mutex_lock(&_mutex);
    int oldMoney = self.totalMoney;
    sleep(0.3);
    oldMoney -= 20;
    self.totalMoney = oldMoney;
    NSLog(@"花20元，余额%d元---%@", self.totalMoney, [NSThread currentThread]);
    pthread_mutex_unlock(&_mutex);
}

最后注意把mutex 销毁掉

- (void)dealloc
{
    pthread_mutex_destroy(& _mutex);
}

递归锁

pthread_mutex的一种，只需要改变 mutex的属性即可： 修改为：PTHREAD_MUTEX_RECURSIVE
注意：

1>如果递归调用的方法里有用到锁，那么就必须用递归锁，否则会出现死锁
2>同一个线程可以对递归锁进行重复上锁

比如：

- (void)viewDidLoad {
    [super viewDidLoad];

    // 初始化属性
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); // recursive
    // 初始化锁
    pthread_mutex_init(&_mutex, &attr);
    // 销毁属性
    pthread_mutexattr_destroy(&attr);
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [self recursive];
    });
}

- (void)recursive {
    // 将_mutex锁上
    pthread_mutex_lock(&_mutex);
    static int count = 0;
    count++;
    if (count <= 5) {
        NSLog(@"%s---%@", __func__, [NSThread currentThread]);
        // 递归
        [self recursive];
    }
    
    // 将_mutex打开
    pthread_mutex_unlock(&_mutex);
}

// 打印
-[ViewController recursive]---<NSThread: 0x6000004735c0>{number = 5, name = (null)}
-[ViewController recursive]---<NSThread: 0x6000004735c0>{number = 5, name = (null)}
-[ViewController recursive]---<NSThread: 0x6000004735c0>{number = 5, name = (null)}
-[ViewController recursive]---<NSThread: 0x6000004735c0>{number = 5, name = (null)}
-[ViewController recursive]---<NSThread: 0x6000004735c0>{number = 5, name = (null)}

pthread_cond（条件锁）

  • 使用
@interface ViewController ()
@property (nonatomic, assign) pthread_cond_t cond;
@property (nonatomic, strong) NSMutableArray *mArray;
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    // 初始化锁
    pthread_mutex_init(&_mutex, NULL);
    // 初始化条件
    pthread_cond_init(&_cond, NULL);
    [self condition];
}

- (void)condition {
    self.mArray = [NSMutableArray new];
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);    dispatch_async(queue, ^{
        sleep(1.0);
        [self add];
    });
    dispatch_async(queue, ^{
        [self remove];
    });
}
- (void)add {
    // 将_mutex锁上
    pthread_mutex_lock(&_mutex);
    [self.mArray addObject:@"1"];
    NSLog(@"%s---%@", __func__, [NSThread currentThread]);
    // 发送信号
    pthread_cond_signal(&_cond);
    // 将_mutex打开
    pthread_mutex_unlock(&_mutex);
}

- (void)remove {
    // 将_mutex锁上
    pthread_mutex_lock(&_mutex);
    if (self.mArray.count == 0) {
        // 等待信号
        pthread_cond_wait(&_cond, &_mutex);
    }
    [self.mArray removeLastObject];
    NSLog(@"%s---%@", __func__, [NSThread currentThread]);
    // 将_mutex打开
    pthread_mutex_unlock(&_mutex);
}
- (void)dealloc {
    // 销毁锁
    pthread_mutex_destroy(&_mutex);
    // 销毁条件
    pthread_cond_destroy(&_cond);
}

// 打印
-[ViewController add]---<NSThread: 0x6000005e3980>{number = 5, name = (null)}
-[ViewController remove]---<NSThread: 0x6000005944c0>{number = 7, name = (null)}

以上如果不加条件信号pthread_cond_signal和等待信号的话pthread_cond_wait，那么打印输出的控制台log的次序会正好相反

  • 说明

1>某个线程中的操作在某种情况下需要依赖另外一个线程中的操作，那么就可以用条件来实现
2>pthread_cond_wait函数会让线程进入休眠状态，并且将锁打开
3>当收到信号时，pthread_cond_wait函数会唤醒线程，并且将锁再次锁上

4、NSLock

它是对pthread_mutex（normal）的封装(互斥锁)
使用：

@interface ViewController ()
@property (nonatomic, strong) NSLock *lock;
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 初始化锁
    self.lock = [NSLock new];
    [self earnAndCostMoney];
}

- (void) earnMoney {
    // 将lock锁上
    [self.lock lock];
    int oldMoney = self.totalMoney;
    sleep(0.3);
    oldMoney += 40;
    self.totalMoney = oldMoney;
    NSLog(@"挣40元，余额%d元---%@", self.totalMoney, [NSThread currentThread]);
    // 将lock打开
    [self.lock unlock];
}

- (void) costMoney {
    // 将lock锁上
    [self.lock lock];
    int oldMoney = self.totalMoney;
    sleep(0.3);
    oldMoney -= 20;
    self.totalMoney = oldMoney;
    NSLog(@"花20元，余额%d元---%@", self.totalMoney, [NSThread currentThread]);
    // 将lock打开
    [self.lock unlock];
}

5、NSRecursiveLock

它是对pthread_mutex（recursive）的封装
使用：

@interface ViewController ()
@property (nonatomic, strong) NSRecursiveLock *lock;
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 初始化锁
    self.lock = [NSRecursiveLock new];
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [self recursive];
    });
}

- (void)recursive {
    // 将lock锁上
    [self.lock lock];
    
    static int count = 0;
    count++;
    if (count <= 5) {
        NSLog(@"%s---%@", __func__, [NSThread currentThread]);
        // 递归
        [self recursive];
    }
    
    // 将lock打开
    [self.lock unlock];
}

6、NSCondition

它是对pthread_mutex和pthread_cond的封装
使用：

@interface ViewController ()
@property (nonatomic, strong) NSCondition *lock;
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 初始化锁
    self.lock = [NSCondition new];
    [self condition];
}

- (void)add {
    // 将lock锁上
    [self.lock lock];

    [self.mArray addObject:@"1"];
    NSLog(@"%s---%@", __func__, [NSThread currentThread]);
    // 发送信号
    [self.lock signal];

    // 将lock打开
    [self.lock unlock];
}

- (void)remove {
    // 将lock锁上
    [self.lock lock];

    if (self.mArray.count == 0) {
        // 等待信号
        [self.lock wait];
    }
    [self.mArray removeLastObject];
    NSLog(@"%s---%@", __func__, [NSThread currentThread]);

    // 将lock打开
    [self.lock unlock];
}

7、NSConditionLock

它是对NSCondition的封装，可以利用条件值来控制线程的执行顺序

@interface ViewController ()
@property (nonatomic, strong) NSConditionLock *lock;
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 条件值初始化为1
    self.lock = [[NSConditionLock alloc] initWithCondition:1];
    [self condition];
}

- (void)condition {
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    dispatch_async(queue, ^{
        [self one];
    });

    dispatch_async(queue, ^{
        [self two];
    });
    
    dispatch_async(queue, ^{
        [self three];
    });
}

- (void)one {
    // 条件值为3往下执行，否则等待
    [self.lock lockWhenCondition:3];

    NSLog(@"%s---%@", __func__, [NSThread currentThread]);

    // 不设置条件值
    [self.lock unlock];
    
    NSLog(@"当前条件值---%zd", self.lock.condition);
}

- (void)two {
    // 条件值为2往下执行，否则等待
    [self.lock lockWhenCondition:2];

    NSLog(@"%s---%@", __func__, [NSThread currentThread]);

    // 条件值设置为3
    [self.lock unlockWithCondition:3];
    
    NSLog(@"当前条件值---%zd", self.lock.condition);
}

- (void)three {
    // 条件值为1往下执行，否则等待
    [self.lock lockWhenCondition:1];

    NSLog(@"%s---%@", __func__, [NSThread currentThread]);

    // 条件值设置为2
    [self.lock unlockWithCondition:2];
    
    NSLog(@"当前条件值---%zd", self.lock.condition);
}

// 打印
-[ViewController three]---<NSThread: 0x600002ae7400>{number = 4, name = (null)}
当前条件值---2
-[ViewController two]---<NSThread: 0x600002ae2680>{number = 6, name = (null)}
当前条件值---3
-[ViewController one]---<NSThread: 0x600002adfa80>{number = 7, name = (null)}
当前条件值---3

参考链接：iOS多线程：十种线程锁, iOS多线程及线程同步方案(线程锁)总结

相关文章

  • iOS关于线程加锁方案

    从前的锁也好看钥匙精美有样子你锁了 人家就懂了 一、存在的问题 1、实例 打印结果（最后余额应该是300的，出问题...

  • iOS 多线程：NSOperation、NSOperationQ

    线程安全解决方案：可以给线程加锁，在一个线程执行该操作的时候，不允许其他线程进行操作。iOS 实现线程加锁有很多种...

  • iOS-面试题3-多线程

    目录： GCD 加锁方案 一. GCD 说一下iOS中多线程的实现方案 ① 这些多线程方案的底层都是依赖pthre...

  • iOS多线程详解

    一 iOS多线程介绍 二 线程同步方案 一 iOS多线程介绍 首先我们先了解一下关于线程的几个概念： 1 什么是进...

  • 线程锁

    iOS 多线程加锁有很多方式：@synchronized、 NSLock、NSRecursiveLock、NSCo...

  • iOS多线程锁之@synchronized原理分析

    在iOS多线程开发当中，不可避免会遇到数据同步的问题，其中一种解决方案就是通过加锁来防止两条线程同时操作同一片内存...

  • 多线程：iOS中的多线程实现方案

    一、iOS的多线程方案二、NSThread的简单使用三、NSOperation的简单使用 一、iOS的多线程方案 ...

  • iOS多线程 线程同步 如何加锁

    本文代码 demo地址 一、 常见的多线程方案 GCD中的一些常见函数 术语 队列及线程使用 二、 线程同步(加锁...

  • 细数iOS中的线程同步方案(一)

    细数iOS中的线程同步方案(一)细数iOS中的线程同步方案(二) 多线程安全问题 多个线程可能访问同一块资源，比如...

  • 05.并发编程之单例和多线程

    1、ThreadLocal 线程局部变量，是一种多线程间并发访问变量的解决方案，与synchronized加锁方式...

网友评论

    本文标题：iOS关于线程加锁方案

    本文链接：https://www.haomeiwen.com/subject/yyksdltx.html

    延伸阅读

    深度阅读

    • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

    栏目导航

    热点阅读

    iOS技术及开发讨论

    关于我们|服务条款|联系我们|iOS关于线程加锁方案|投稿指南|网站地图|RSS订阅|排版工具|手机版

    提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

    Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

    备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

    本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

    所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！