iOS 锁分析下:各种锁的使用&源码分析&读写锁

准备工作

  • swift-corelibs-foundation 源码

一、锁的分类

互斥锁

互斥锁有互斥同步两条特性,互斥性:当多条线程同时处理一个任务时,一条线程在处理任务,其他线程安全教育日都不能再进行处理,只有该任务结束运行后才可以运行。同步源码性:首先要满足互斥性,还要有执行的顺序。常用的有:

  • @sy安全教育日nchronized
  • NSLock
  • pthread_mutex

自旋锁

自旋锁相当于互斥锁+忙等,当其检测到资源不可用时,会保持一种初始化的状态,直到获取该资源。它的优势在于避免了上下文的切换,非常适合于堵塞线程池的七个参数时间很短的场合。缺点则是变量泵忙等的状初始化磁盘态下会不停的检测状态,会占用cpu资源。常用的有:

  • OSSpinLock
  • atomic

条件锁

通过一些条件来控制资源的访问,当然条件是会发生变化的。常用的有:

  • NSCondition
  • NSConditionLock

信号量

是一种高级的同步机制。互斥锁可以认为是信号量取值0/1时的特例,可以线程池的七个参数实现更加复杂的同步。常用的有:

  • dispatch_semaphore

递归锁初始化sdk什么意思

它允许同一线程多次加锁,而不会造成死锁。递归锁是特殊的互斥锁,主要是用在循环或递归操作中。常用的有:

  • pthread_mutex(recursive)
  • NSRecursiveLock

读写锁安全教育手抄报

是并发控制的一种同步机制,也称“共享-互斥锁”,也是一种特殊的自旋锁。它把对资源的访问者分为读者和写者,它允许同时有多个变量名读者访问资源,但是只允许有一个写者来访问资源源码。常用的有:

  • pthread(rwlock)
  • dispatch_barrier_async / dispatch_barrier_sync

二、NSLo变量类型有哪些ck 和 NSRecur源码精灵永久兑换码siveLock 的分析

先看下面的示例代码,外层是for循环,内层是block的递归调用:

- (void)ssl_testRecursive {
    for (int i = 0; i < 10; i++) {
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            static void (^testMethod)(int);
            testMethod = ^(int value){
                if (value > 0) {
                    NSLog(@"current value= %d",value);
                    testMethod(value - 1);
                }
            };
            testMethod(10);
        });
    }
}

查看执行结果:

iOS 锁分析下:各种锁的使用&源码分析&读写锁

  • 可以看到value值是乱序打印的,如果我们想要顺序打印,就要给代码加锁,那么该怎么加锁呢。

NSLock 示例

testMethod(10);的执行前后加上NSLock锁:

iOS 锁分析下:各种锁的使用&源码分析&读写锁

  • 没有问题,可以顺序打印。

有的时候,我们喜欢把加锁和业务代码写在一起,也就是初始化电脑testMethodblock中加锁:

iOS 锁分析下:各种锁的使用&源码分析&读写锁

  • 只打印了一个10,为什么呢,因为这是个递归函数,会递归加锁,而NSLock是非递归锁,所以无法正常执行。

NSRecursiv安全教育日eLock 示例

N初始化失败是怎么解决SRecursiveLock是递归锁,我们安全教育手抄报N变量类型有哪些SLock换成NSRecursiveLock源码1688,运行程序:初始化英文

iOS 锁分析下:各种锁的使用&源码分析&读写锁

  • 初始化英文序从101只顺序打印了1次,这又是为什么呢,因为NSRecursiveLock只是递归锁,可以解决递归性但是解决不了多线程性,那么既要满足递归性又要满足多线程性就需要用到我们 上一篇 分析的@synchronized

@synchronized 示例

使用@synchronized,程序正常打印:

iOS 锁分析下:各种锁的使用&源码分析&读写锁

三、NSCondition 的分析

简介

SCondition是一个条件锁,在日常开发中使用较少,与信号量有点相似:线程需要满足条件才会往下走初始化电脑时出现问题,否则会堵塞变量的定义等待,直到条件满足,是经典的生产消费者模型

NSCondition的对象实际上作为一个和一个线程线程池面试题检查器

  • 主要为了变量类型有哪些当检测条件时保护数据源,执行条件引发的任务
  • 线程检查器主要是根据条件决定是否继续运行线程,即线程安全线程是否被阻塞

相关函数

//一般用于多线程同时访问、修改同一个数据源,保证在同一时间内数据源只被访问、修改一次,其他线程的命令需要在lock 外等待,只到 unlock ,才可访问
[condition lock];
//与lock 同时使用
[condition unlock];
//让当前线程处于等待状态
[condition wait];
//CPU发信号告诉线程不用在等待,可以继续执行
[condition signal];

生产消费者模安全工程师型 示例

- (void)viewDidLoad {
    [super viewDidLoad];
    [self ssl_testConditon];
}
- (void)ssl_testConditon {
    _testCondition = [[NSCondition alloc] init];
    //创建生产-消费者
    for (int i = 0; i < 50; i++) {
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
            [self ssl_producer];
        });
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
            [self ssl_consumer];
        });
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
            [self ssl_consumer];
        });
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
            [self ssl_producer];
        });
    }
}
- (void)ssl_producer {
    [_testCondition lock]; // 操作的多线程影响
    self.ticketCount = self.ticketCount + 1;
    NSLog(@"生产一个 现有 count %zd",self.ticketCount);
    [_testCondition signal]; // 信号
    [_testCondition unlock];
}
- (void)ssl_consumer {
     [_testCondition lock];  // 操作的多线程影响
    if (self.ticketCount == 0) {
        NSLog(@"等待 count %zd",self.ticketCount);
        [_testCondition wait];
    }
    //注意消费行为,要在等待条件判断之后
    self.ticketCount -= 1;
    NSLog(@"消费一个 还剩 count %zd ",self.ticketCount);
     [_testCondition unlock];
}
执行结果:
生产一个 现有 count 1
消费一个 还剩 count 0 
等待 count 0
等待 count 0
生产一个 现有 count 1
消费一个 还剩 count 0 
生产一个 现有 count 1
消费一个 还剩 count 0 
等待 count 0
生产一个 现有 count 1
...
  • 生产者生产,消费者消线程数越多越好吗费,消费者消费生产者生产的,如果不能生产就不能消费。
  • 生产者和消费者,本身要是初始化失败是怎么解决安全的要进行加锁,它们之间又有联系,需要信线程安全号的控制,消费为0时要进行等待,生产有了以后不能让消费一直等待,要发送信号消费者就可以结束等待继续执行。

四、foundation 源码关于锁的封装

我们看下NSLock的定义:

iOS 锁分析下:各种锁的使用&源码分析&读写锁

  • lockunlockNSLocking的协议方法,是一个锁的协议,很多锁都有这两个方法,接下来结合swift-corelibs-foundation源码分析NSLock到底是怎么实现的。

NSLock 源码分析

查看NSLock安全工程师源码:

iOS 锁分析下:各种锁的使用&源码分析&读写锁

  • 可以看到NSLock源码中确实是实现了NSLocking协议,线程数是什么初始化时,本质上是对pthread_mutex源码之家进行的封装,调用的都是变量pthread_mutex的函数。

查看lockunlock的实变量现:

iOS 锁分析下:各种锁的使用&源码分析&读写锁

  • 可以看到lockunlock也是初始化是什么意思pthread_mutex进行的封装。

NSRecursiveLock 源码分析

查看NSRecursiveLock源码:

iOS 锁分析下:各种锁的使用&源码分析&读写锁

  • 可以看到NSRecursiveLock也实现了NSLocking协议,初始化也是用pthread_mutex进行的封装,不同之处在源码编辑器下载NSRecursiveLock安全模式有设置PTHREAD_MUTEX_RECURSIVE这个type,这里就决定了它是个递归锁

N初始化英文SRecursiveLocklockunlock的实现和NSLock基本是一样的,都是对pthread_mutex的封装:

iOS 锁分析下:各种锁的使用&源码分析&读写锁

NSCondition 源码分析

查看NSConditi初始化on源码:

iOS 锁分析下:各种锁的使用&源码分析&读写锁

  • NSConditi安全on也实现了NSLoc变量king协议,初始化也是用pthread_mu变量之间的关系tex进行的封装,区别就在于封装了cond的相关操作,使它拥有了waitsignal等功能。

lockunlock也是对pthread_mutex的封装:

iOS 锁分析下:各种锁的使用&源码分析&读写锁

五、NSConditionLock 分析

NSConditionLock 示例

看下面的示例代码及执行结果:

- (void)ssl_testConditonLock{
    NSConditionLock *conditionLock = [[NSConditionLock alloc] initWithCondition:2];
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
        [conditionLock lockWhenCondition:1];
        NSLog(@"线程 1");
        [conditionLock unlockWithCondition:0];
    });
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0), ^{
        [conditionLock lockWhenCondition:2];
        sleep(0.1);
        NSLog(@"线程 2");
        [conditionLock unlockWithCondition:1];
    });
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
       [conditionLock lock];
       NSLog(@"线程 3");
       [conditionLock unlock];
    });
    //
}
执行结果:
线程 3
线程 2
线程 1
  • 线程 2一定在线程 1之前先执行,因为我们初始化condi线程池面试题tionLock时指定的condition等于2,所以lockWhenCondition:2可以正常执行,unlockWithCondition:1安全教育平台登录以后lockWhenCond安全教育平台登录ition:1才能执行。
  • 线程 3中只是普通的lock所以是可以正常执行,线程 2线程 3本来是乱序的,但我们在线程 2加了sleep(0.1)安全生产法迟操作,所以线程 3先执行。

NSConditionLock 源码分析

初始化源码分析

打开源码,查看NSConditionLock的初始化:

iOS 锁分析下:各种锁的使用&源码分析&读写锁

  1. 通过NSCo源码交易平台nd变量类型有哪些ition()初始线程撕裂者化了成员变量_cond
  2. 初始化_value成员变量为0

lockWhen变量名Condition: 源码分析

查看lockWhenCondition:源码:

iOS 锁分析下:各种锁的使用&源码分析&读写锁

继续进入whenCondition:before:

iOS 锁分析下:各种锁的使用&源码分析&读写锁

  • _value != condition时进行源码编程器while死循环,循环中安全教育平台判断等待是否超时,如果超时了返回fa源码lse,如果等到_value == condition向下执行返回true,任务正常执行。

unloc源码时代kWithCondition: 源码分析

unlockWithCondition:

iOS 锁分析下:各种锁的使用&源码分析&读写锁

  • 更新_变量类型有哪些value值为传进来的condition
  • _cond.broadcast()进行广播通知,通知等待中的任务_value值的改变。

六、读写锁

读写锁 概念

  • 读写锁实际是一种特殊的互斥锁,它把对共享资源的访问者划分成读者和写者,读者只对共享资源进行读访问,写者则需要对共享资源进行写操作。这种锁相对于自旋锁而言,能提高并发性,因为在多处理器系统中,它允许同时有多个读者来访问共享资源,最大可初始化电脑的后果能的读者数为实际的逻辑CPU数。写者是初始化电脑排他性的,一个读写锁同时只能有一个写者或多个读者(与CPU数相关),但不能同时既有读者又有写者。在读写锁保持期间也是抢占失效的。
  • 如果读写锁当前没有读者,也没有写者,那么写者初始化失败是怎么解决可以立刻获得读写锁,否则它必须自旋在那里,直到没有任何写者或读者。如果安全生产法读写锁没有写变量泵者,那么读者可以立即获得该读写锁,否则读者必须自旋在那里,直到写者释放该读写锁。

  • 一次只有一个线程可以占有安全教育日写模式的读写锁, 但是可变量以有多个线程同时占有读模式的读写锁,正是因为这初始化是什么意思个特性,当读写锁是写加锁状态时, 在这个锁被解锁之前, 所有试图对这个锁加锁的线程都会被阻塞
  • 当读写锁在读加变量值锁状态时, 所有试图以读模式对它进行加锁的线程都可以得到访问权, 但是如果线程希望以写模式对此锁进行源码网站加锁, 它必须直到所有的线程释放锁。
  • 通常,当读写锁处于读模式锁住状态时, 如果有另外线程试图以写模式加锁, 读写锁通常会阻塞随后的读模式锁请求, 这样可以避免读模式锁⻓期占用, 而等待的写模式锁请求⻓期阻塞。
  • 读写锁适合于对数据结构的读次数比写次数多得多的情况. 因为, 读模式锁定时变量与函数可以共享, 以写模式锁住时意味着独占, 所以读写锁又叫共享-独占锁

总结一下就是:

  • 多读单写
  • 写 和 写互斥
  • 写 和 读互斥
  • 线程和进程的区别是什么、写 不能阻塞任务执行

栅栏函数 实现读写锁

@interface ViewController ()
@property (nonatomic, strong) dispatch_queue_t ssl_safeQueue;
@property (nonatomic, strong) NSMutableDictionary *mDict;
@end
@implementation ViewController
- (void)viewDidLoad {
    [super viewDidLoad];
    [self ssl_safeSetter:@"111" time:4];
    [self ssl_safeSetter:@"222" time:3];
    [self ssl_safeSetter:@"333" time:2];
    [self ssl_safeSetter:@"444" time:1];
}
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    for (int i = 0; i < 10000; i++) {
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            NSLog(@"读取情况:%@ -- %d -- %@",[self ssl_safeGetter],i,[NSThread currentThread]);
        });
    }
}
- (void)ssl_safeSetter:(NSString *)name time:(int)time {
    dispatch_barrier_async(self.ssl_safeQueue, ^{
        sleep(time);
        [self.mDict setValue:name forKey:@"ssl"];
        NSLog(@"写情况:%@ - %@",self.mDict[@"ssl"],[NSThread currentThread]);
    });
}
- (NSString *)ssl_safeGetter {
    __block NSString *result;
    dispatch_sync(self.ssl_safeQueue, ^{
        result = self.mDict[@"ssl"];
    });
    return result;
}
- (dispatch_queue_t)ssl_safeQueue
{
    if (!_ssl_safeQueue) {
        _ssl_safeQueue = dispatch_queue_create("ssl", DISPATCH_QUEUE_CONCURRENT);
    }
    return _ssl_safeQueue;
}
- (NSMutableDictionary *)mDict
{
    if (!_mDict) {
        _mDict = [NSMutableDictionary new];
    }
    return _mDict;
}
@end
  • 写操作中我们使用dispatch_barrier_async函数,使用这个函数前面的任务执行完才会执行这里,这里执安全教育平台登录行完才会执行后面的任务,这样可以达到写和写互斥的目的。
  • 读操作也是放在了self.s初始化游戏启动器失败sl_safeQueue中,这样读和写互斥就完成了,也就真正意义的达成单写的目的,注意这里的dispatch_sync只是阻塞当前任务的线程,否则 result 就获取不到值了。
  • 因为self.ssl_safeQueue并发队列,所以多读也是没问题的。

发表评论

提供最优质的资源集合

立即查看 了解详情