美文网首页iOS进阶
09.1-多线程中的各种锁操作

09.1-多线程中的各种锁操作

作者: 光强_上海 | 来源:发表于2020-06-21 18:19 被阅读0次

    我们在平时的开发过程中可能会遇到多个线程并发同时访问同一资源的情况，例如数据库的存取操作，或者是文件的读写操作，像这种多个线程同时访问同一资源就会容易产生资源竞争，导致数据错乱的问题，解决这种问题我们一般会选择使用线程同步技术，也就是对这同一资源进行加锁解锁操作，iOS中的锁主要有以下几种：

    • OSSpinLock(在iOS10已经废弃了)
    • os_unfair_lock
    • pthread_mutex_t
    • pthread_cond_t
    • NSLock
    • NSConditionLock
    • @synchronized
    • dispatch_semaphore_t：信号量也可以作为锁来使用
    • dispatch_sync(DISPATCH_QUEUE_SERIAL)：使用串行同步队列也可以作为锁来使用
    image image image image

    下面我们就逐一对上面列出的锁进行简单地使用示例说明

    OSSpinLock基本用法：

    @interface OSSpinLockDemo ()

@property (nonatomic, assign) OSSpinLock ossLock;
@end

@implementation OSSpinLockDemo

- (instancetype)init {
    if (self = [super init]) {
            // 初始化自旋锁
        _ossLock = OS_SPINLOCK_INIT;
    }
    return self;
}

- (void)test {
    
    // 加锁
    OSSpinLockLock(&_ossLock);
    
    // 需要加锁的代码放在加锁和解锁语句中间，例如下面的NSLog打印
    NSLog(@"加锁代码");
    
    // 解锁
    OSSpinLockUnlock(&_ossLock);
}
@end
    image

    os_unfair_lock基本用法：

    @interface OSUnfairLockDemo ()

@property (nonatomic, assign) os_unfair_lock lock;
@end

@implementation OSUnfairLockDemo

- (instancetype)init {
    if (self = [super init]) {
        // 初始化锁
        _lock = OS_UNFAIR_LOCK_INIT;
    }
    return self;
}

- (void)test {
    // 加锁
    os_unfair_lock_lock(&_lock);
    
    // 需要加锁的代码
    
    // 解锁
    os_unfair_lock_unlock(&_lock);
}
@end
    image

    pthread_mutex_t基本用法：

    @interface pthreadMutexLockDemo ()
    
@property (nonatomic, assign) pthread_mutex_t mutex;
@end

@implementation pthreadMutexLockDemo

- (instancetype)init {
    if (self = [super init]) {
        // 初始化属性
//        pthread_mutex_t attr;
//        pthread_mutexattr_init(&attr);
            // PTHREAD_MUTEX_DEFAULT：是普通互斥锁
            // PTHREAD_MUTEX_RECURSIVE：递归锁
//        pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_DEFAULT);
//
//        // 初始化锁
//        pthread_mutex_init(&_mutex, &attr);
//
//        // 销毁属性
//        pthread_mutexattr_destroy(&attr);
        
        // 最简单的初始化方式是第二个参数直接填NULL即可
        pthread_mutex_init(&_mutex, NULL);
    }
    return self;
}

- (void)test {
    // 加锁
    pthread_mutex_lock(&_mutex);
    
    // 需要加锁的代码
    
    // 解锁
    pthread_mutex_unlock(&_mutex);
}

- (void)dealloc {
    // 销毁锁
    pthread_mutex_destroy(&_mutex);
}
@end
    image

    pthread_cond_t基本使用：

    @interface pthreadMutexConditionLockDemo ()
    
@property (nonatomic, assign) pthread_mutex_t mutex;
@property (nonatomic, assign) pthread_cond_t con;
@property (nonatomic, strong) NSMutableArray *data;
@end

@implementation pthreadMutexConditionLockDemo

- (instancetype)init {
    if (self = [super init]) {
        // pthread_mutex_init 第二个参数可以参NULL
        pthread_mutex_init(&_mutex, NULL);
        pthread_cond_init(&_con, NULL);
        
        _data = [NSMutableArray array];
    }
    return self;
}

- (void)test {
    [[[NSThread alloc] initWithTarget:self selector:@selector(remove) object:nil] start];
    
    sleep(2);
    
    [[[NSThread alloc] initWithTarget:self selector:@selector(add) object:nil] start];
}

- (void)remove {
    // 加锁
    pthread_mutex_lock(&_mutex);
    
    if (!self.data.count) {
        // 线程等待
        pthread_cond_wait(&_con, &_mutex);
    }
    
    [self.data removeLastObject];
    NSLog(@"删除元素");
    
    // 解锁
    pthread_mutex_unlock(&_mutex);
}

- (void)add {
    // 加锁
    pthread_mutex_lock(&_mutex);
    
    [self.data addObject:@"111"];
    NSLog(@"添加元素");
    
    // 唤醒等待的线程
    pthread_cond_signal(&_con);
    
    // 解锁
    pthread_mutex_unlock(&_mutex);
}

- (void)dealloc {
    pthread_mutex_destroy(&_mutex);
    pthread_cond_destroy(&_con);
}
@end
    image

    NSLock基本用法：

    @interface NSLockDemo ()

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

@implementation NSLockDemo

- (instancetype)init {
    if (self = [super init]) {
            // 初始化锁
        _lock = [[NSLock alloc] init];
    }
    return self;
}

- (void)test {
     // 加锁
    [self.lock lock];
    
    // 加锁的代码
    
    // 解锁
    [self.lock unlock];
}
@end
    image

    NSConditionLock：基本用法

    @interface NSConditionLockDemo ()
    
@property (nonatomic, strong) NSConditionLock *conLock;
@end

@implementation NSConditionLockDemo

- (instancetype)init {
    if (self = [super init]) {
        // 初始化锁
        _conLock = [[NSConditionLock alloc] initWithCondition:1];
    }
    return self;
}

- (void)test {
    [[[NSThread alloc] initWithTarget:self selector:@selector(remove) object:nil] start];
    
    sleep(2);
    
    [[[NSThread alloc] initWithTarget:self selector:@selector(add) object:nil] start];
}

- (void)remove {
    // 加锁
    [self.conLock lockWhenCondition:1];
    
    NSLog(@"删除元素");
    
    // 解锁
    [self.conLock unlockWithCondition:2];
}

- (void)add {
    // 加锁
    [self.conLock lockWhenCondition:2];
    
    NSLog(@"添加元素");

    // 解锁
    [self.conLock unlock];
}
@end
    image

    @synchronized基本用法：

    @implementation synchronizedLockDemo

- (void)test {
    // 根据传递的slef生成对应的锁，传入不同的对象生成不同的锁，底层是mutex 递归锁
    @synchronized (self) {
        // 需要加锁的代码
    }
}
@end
    image

    dispatch_semaphore_t基本用法：

    @interface semaphoneLockDemo ()

@property (nonatomic, strong) dispatch_semaphore_t semaphone;
@end

@implementation semaphoneLockDemo

- (instancetype)init {
    if (self = [super init]) {
            // 初始化信号量，1表示同时只能有1个线程来执行任务
        _semaphone = dispatch_semaphore_create(1);
    }
    return self;
}

- (void)test {
    for (NSInteger i = 0; i < 20; i ++) {
        [[[NSThread alloc] initWithTarget:self selector:@selector(doTask) object:nil] start];
    }
}

- (void)doTask {
    
    // 如果信号量的值>0，信号量的值就-1，然后执行后面的代码，DISPATCH_TIME_FOREVER：一直等
    // 如果信号量的值<=0，此时就进入休眠，等待信息量的值变成>0
    dispatch_semaphore_wait(self.semaphone, DISPATCH_TIME_FOREVER);
    
    sleep(2);
    NSLog(@"1212");
    
    // 让信号量的值+1
    dispatch_semaphore_signal(self.semaphone);
}
@end
    image

    dispatch_sync(DISPATCH_QUEUE_SERIAL)基本用法：

    @interface SerialQueueLockDemo ()

@property (nonatomic, strong) dispatch_queue_t ticketQueue;
@end

@implementation SerialQueueLockDemo

- (instancetype)init {
    if (self = [super init]) {
        _tickeetQueue = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);
    }
    return self;
}

- (void)test {
    dispatch_sync(self.tickeetQueue, ^{
        // 加锁的代码
    });
}
@end
    image

    上面我们列举了iOS中的几种锁，但是有的锁已经废弃了，有的锁性能上存在些问题，那么我们在平时的开发中会选用哪种锁来使用比较合适尼，这里根据大量的三方框架和苹果底层框架中使用到的锁的情况来看，NSLock，pthread_mutex，dispatch_semaphore是出现频次最多的

    image image

    上面我们介绍的这些锁对于多个异步线程同时访问同一资源时，使用这些锁来进行线程同步确实是可以解决问题，但是如果我们是对文件进行读写操作，这时上面的锁就不太适合使用了，因为文件读写操作的特点是可以同时读，但是不能同时写，也不能在读的时候进行写操作，也不能在写的时候进行读操作，所以就有了下面的两种专门处理文件读写操作的锁：

    • pthread_rwlock_t
    • dispatch_barrier_async：异步栅栏也可以解决文件读写操作
    image

    pthread_rwlock_t基本用法：

    @interface pthread_rwlockDemo ()

@property (nonatomic, assign) pthread_rwlock_t rwlock;
@end

@implementation pthread_rwlockDemo

- (void)test {
    // 初始化锁
    pthread_rwlock_init(&_rwlock, NULL);
    
    for (NSInteger i = 0; i < 10; i++) {
        
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            [self read];
        });
        
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            [self write];
        });
    }
}

- (void)read {
    
    // 读加锁
    pthread_rwlock_rdlock(&_rwlock);
    
    sleep(1);
    
    NSLog(@"开始读");
    
    // 解锁
    pthread_rwlock_unlock(&_rwlock);
}

- (void)write {
    // 写加锁
    pthread_rwlock_wrlock(&_rwlock);
    
    sleep(1);
    
    NSLog(@"开始写");
    
    // 解锁
    pthread_rwlock_unlock(&_rwlock);
}

- (void)dealloc {
    // 销毁锁
    pthread_rwlock_destroy(&_rwlock);
}
@end
    image

    dispatch_barrier_async：基本用法：

    @interface dispatch_barrier_asyncDemo ()

@property (nonatomic, strong) dispatch_queue_t queue;
@end

@implementation dispatch_barrier_asyncDemo

- (void)test {
    // 创建一个并发队列，注意：这里使用dispatch_barrier_async只能使用`dispatch_queue_create`创建一个并发队列，不能使用全局并发队列
    self.queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
    
    for (NSInteger i = 0; i < 10; i ++) {
        [self read];
        [self read];
        [self read];
        [self read];
        [self write];
    }
}

- (void)read {
    dispatch_async(self.queue, ^{
        sleep(1);
        NSLog(@"开始读");
    });
}

- (void)write {
    dispatch_barrier_async(self.queue, ^{
        // 开始加锁
        sleep(1);
        NSLog(@"开始写");
    });
}
@end
    image

    讲解示例Demo地址：https://github.com/guangqiang-liu/09.1-ThreadLock

    更多文章

    相关文章

      网友评论

        本文标题：09.1-多线程中的各种锁操作

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

        延伸阅读

        深度阅读

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

        栏目导航

        热点阅读

        iOS进阶

        关于我们|服务条款|联系我们|09.1-多线程中的各种锁操作|投稿指南|网站地图|RSS订阅|排版工具|手机版

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

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

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

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

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