iOS中常见的各种锁

一. 自旋锁、递归锁、互斥锁

首先看一下它们的性能对比：
性能对比图

下面开始逐个分析

1. OSSpinLock 自旋锁

参考YY大神的不再安全的自旋锁

引入头文件 #import <libkern/OSAtomic.h>

- (void)viewDidLoad {
    [super viewDidLoad];

    [self testLock];
    
}

- (void)testLock {
    
    dispatch_queue_t queue = dispatch_queue_create("com.test.a", DISPATCH_QUEUE_CONCURRENT);
    
    //设置票的数量为5
    _tickets = 5;
    //创建锁
    _pinLock = OS_SPINLOCK_INIT;
    //线程1
    dispatch_async(queue, ^{
        [self saleTickets];
    });
    //线程2
    dispatch_async(queue, ^{
        [self saleTickets];
    });


}

- (void)saleTickets
{
    while (1) {
        [NSThread sleepForTimeInterval:1];
        //加锁
        OSSpinLockLock(&_pinLock);
        
        if (_tickets > 0) {
            _tickets--;
            NSLog(@"剩余票数= %ld, Thread:%@",_tickets,[NSThread currentThread]);
            
        } else {
            NSLog(@"票卖完了  Thread:%@",[NSThread currentThread]);
            break;
        }
        //解锁
        OSSpinLockUnlock(&_pinLock);
    }
}

2. os_unfair_lock iOS10以后代替自旋锁

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

- (void)viewDidLoad {
    [super viewDidLoad];

    [self testLock];
    
}

- (void)testLock {
    
    dispatch_queue_t queue = dispatch_queue_create("com.test.a", DISPATCH_QUEUE_CONCURRENT);
    
    //设置票的数量为5
    _tickets = 5;
    //创建锁
    _pinLock = OS_UNFAIR_LOCK_INIT;
    //线程1
    dispatch_async(queue, ^{
        [self saleTickets];
    });
    //线程2
    dispatch_async(queue, ^{
        [self saleTickets];
    });


}

- (void)saleTickets
{
    while (1) {
        //加锁
        os_unfair_lock_lock(&_pinLock);
        [NSThread sleepForTimeInterval:1];

        if (_tickets > 0) {
            _tickets--;
            NSLog(@"剩余票数= %ld, Thread:%@",_tickets,[NSThread currentThread]);
            
        } else {
            NSLog(@"票卖完了  Thread:%@",[NSThread currentThread]);
            break;
        }
        //解锁
        os_unfair_lock_unlock(&_pinLock);
    }
}

3. dispatch_semaphore 信号量实现加锁

dispatch_semaphore实现的原理,首先会先将信号量减一，并判断是否大于等于0，如果是，则返回0，并继续执行后续代码，否则，使线程进入睡眠状态，让出cpu时间。直到信号量大于0或者超时，则线程会被重新唤醒执行后续操作。
dispatch_semaphore_create(1);为1说明只可以同时执行一个线程,如果为2可以同时执行两个线程,为N可以同时执行N个线程,同时执行也就是说同时执行的这些线程不具备线程安全

- (void)viewDidLoad {
    [super viewDidLoad];

    [self testLock];
    
}

- (void)testLock {
    
    dispatch_queue_t queue = dispatch_queue_create("com.test.a", DISPATCH_QUEUE_CONCURRENT);
    __block int i = 0;
    
    // 创建信号量
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
    //线程1
    dispatch_async(queue, ^{
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        i++;
        sleep(1);
        i--;
        NSLog(@"任务1 %d", i);
        dispatch_semaphore_signal(semaphore);
    });
    
    //线程2
    dispatch_async(queue, ^{
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        i++;
        sleep(1);
        i--;
        NSLog(@"任务2 %d", i);
        dispatch_semaphore_signal(semaphore);
    });
    
    //线程3
    dispatch_async(queue, ^{
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        i++;
        sleep(1);
        i--;
        NSLog(@"任务3 %d", i);
        dispatch_semaphore_signal(semaphore);
    });
}

例如以上代码,当dispatch_semaphore_create(3) 填写大于等于2时,输出结果是不确定的,如下所示

2019-03-09 21:26:53.920783+0800 test[5048:460547] 任务1 2
2019-03-09 21:26:53.920783+0800 test[5048:460548] 任务2 2
2019-03-09 21:26:53.920784+0800 test[5048:460545] 任务3 1

2019-03-09 21:28:53.449173+0800 test[5083:462224] 任务1 1
2019-03-09 21:28:53.449174+0800 test[5083:462242] 任务2 2
2019-03-09 21:28:53.449251+0800 test[5083:462225] 任务3 0

只有填写1的时候才能保证线程安全

4. pthread_mutex 互斥锁

阻塞线程并进入睡眠

- (void)viewDidLoad {
    [super viewDidLoad];

    [self testLock];
    
}

- (void)testLock {
    
    dispatch_queue_t queue = dispatch_queue_create("com.test.a", DISPATCH_QUEUE_CONCURRENT);
    
    __block pthread_mutex_t mutex;
    pthread_mutex_init(&mutex, NULL);
    
    //线程1
    dispatch_async(queue, ^{
        pthread_mutex_lock(&mutex);
        NSLog(@"任务1");
        sleep(2);
        pthread_mutex_unlock(&mutex);
    });
    
    //线程2
    dispatch_async(queue, ^{
        pthread_mutex_lock(&mutex);
        NSLog(@"任务2");
        sleep(1);
        pthread_mutex_unlock(&mutex);
    });


}

5. NSLock 互斥锁 不能多次调用 lock方法,会造成死锁

NSLock在内部封装了一个 pthread_mutex
在Cocoa程序中NSLock中实现了一个简单的互斥锁。 所有锁（包括NSLock）的接口实际上都是通过NSLocking协议定义的，它定义了lock和unlock方法。你使用这些方法来获取和释放该锁。 NSLock类还增加了tryLock和lockBeforeDate:方法。 tryLock试图获取一个锁，但是如果锁不可用的时候，它不会阻塞线程，相反，它只是返回NO。 lockBeforeDate:方法试图获取一个锁，但是如果锁没有在规定的时间内被获得，它会让线程从阻塞状态变为非阻塞状态（或者返回NO）。

- (void)viewDidLoad {
    [super viewDidLoad];

    [self testLock];
    
}

- (void)testLock {
    //设置票的数量为5
    _tickets = 5;
    
    _mutexLock = [[NSLock alloc] init];
    dispatch_queue_t queue = dispatch_queue_create("com.test.a", DISPATCH_QUEUE_CONCURRENT);
    
    //线程1
    dispatch_async(queue, ^{
        [self saleTickets];
    });
    
    //线程2
    dispatch_async(queue, ^{
        [self saleTickets];
    });
}

- (void)saleTickets
{
    while (1) {
        [NSThread sleepForTimeInterval:1];
        //加锁
        [_mutexLock lock];
        if (_tickets > 0) {
            _tickets--;
            NSLog(@"剩余票数= %ld, Thread:%@",_tickets,[NSThread currentThread]);
        } else {
            NSLog(@"票卖完了  Thread:%@",[NSThread currentThread]);
            break;
        }
        //解锁
        [_mutexLock unlock];
    }
}

结果和上边一样就不再赘述

6. NSCondition

NSCondition有点类似于python的协程,先执行一部分任务,如果条件不满足，先跳转到其他地方执行,等到条件满足了以后再回来。内部是对pthread_mutex_t和pthread_cond_t的封装。可用于生产者、消费者。

- (void)viewDidLoad {
    [super viewDidLoad];

    [self testLock];
    
}

- (void)testLock {
    _condition = [[NSCondition alloc] init];
    
    dispatch_queue_t queue = dispatch_queue_create("com.test.a", DISPATCH_QUEUE_CONCURRENT);
    
    //设置票的数量为5
    _tickets = 5;
    //线程1
    dispatch_async(queue, ^{
        [self saleTickets1];
    });
    
    //线程1
    dispatch_async(queue, ^{
        [self saleTickets2];
    });
}

- (void)saleTickets1
{

    [_condition lock];
    _tickets--;
    NSLog(@"剩余票数 = %ld, Thread:%@", _tickets, [NSThread currentThread]);
    if (_tickets == 4) {
        [_condition wait];
    }
    _tickets--;
    NSLog(@"剩余票数 = %ld, Thread:%@", _tickets, [NSThread currentThread]);
    [_condition unlock];
}

- (void)saleTickets2
{
    //加锁
    [_condition lock];
    [NSThread sleepForTimeInterval:1];
    _tickets--;
    NSLog(@"我是VIP我来插队了 剩余票数 = %ld, Thread:%@", _tickets, [NSThread currentThread]);
    [_condition signal];
    //解锁
    [_condition unlock];

7. pthread_mutex(recursive) 递归锁

- (void)viewDidLoad {
    [super viewDidLoad];

    [self testLock];
    
}

- (void)testLock {
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
    
    pthread_mutex_init(&_lock, &attr);    //设置属性
    
    dispatch_queue_t queue = dispatch_queue_create("com.test.a", DISPATCH_QUEUE_CONCURRENT);
    
    //设置票的数量为5
    _tickets = 5;
    //线程1
    dispatch_async(queue, ^{
        [self saleTickets];
    });
}

- (void)saleTickets
{
    while (1) {
        //加锁
        pthread_mutex_lock(&_lock);
        [NSThread sleepForTimeInterval:1];

        if (_tickets > 0) {
            _tickets--;
            NSLog(@"剩余票数= %ld, Thread:%@",_tickets,[NSThread currentThread]);
            [self saleTickets];
            
        } else {
            NSLog(@"票卖完了  Thread:%@",[NSThread currentThread]);
            break;
        }
        //解锁
        pthread_mutex_unlock(&_lock);
    }
}

8. NSRecursiveLock 递归锁，是对mutex递归锁的封装，API跟NSLock基本一致。

使用锁最容易犯的一个错误就是在递归或循环中造成死锁 如下代码中，因为在线程1中的递归block中，锁会被多次的lock，所以自己也被阻塞了

- (void)viewDidLoad {
    [super viewDidLoad];

    [self testLock];
    
}

- (void)testLock {
    
    _mutexLock = [[NSLock alloc] init];
    dispatch_queue_t queue = dispatch_queue_create("com.test.a", DISPATCH_QUEUE_CONCURRENT);
    
    static void(^TestBlock)(int);
    
    //线程1
    dispatch_async(queue, ^{
        TestBlock = ^(int value)
        {
            [_mutexLock lock];
            if (value > 0)
            {
                [NSThread sleepForTimeInterval:1];
                int count = --value;
                NSLog(@"count: %d", count);
                TestBlock(count);
            }
            [_mutexLock unlock];
        };
        
        TestBlock(5);
    });

}

以上将NSLock换成NSRecursiveLock，便可解决问题。
_mutexLock = [[NSRecursiveLock alloc] init];
NSRecursiveLock类定义的锁可以在同一线程多次lock，而不会造成死锁。
递归锁会跟踪它被多少次lock。每次成功的lock都必须平衡调用unlock操作。
只有所有的锁住和解锁操作都平衡的时候，锁才真正被释放给其他线程获得。

9. NSConditionLock 条件锁

NSConditionLock封装了一个互斥锁和条件变量，是对NSCondition的进一步封装。互斥锁保证线程安全，条件变量保证执行顺序。可以通过此锁实现控制线程的执行顺序。
条件锁，一个线程获得了锁，其它线程等待。
[xxxx lock];
表示 xxx 期待获得锁，如果没有其他线程获得锁（不需要判断内部的condition) 那它能执行此行以下代码，如果已经有其他线程获得锁（可能是条件锁，或者无条件锁），则等待，直至其他线程解锁
[xxx lockWhenCondition:A条件];
表示如果没有其他线程获得该锁，但是该锁内部的condition不等于A条件，它依然不能获得锁，仍然等待。如果内部的condition等于A条件，并且没有其他线程获得该锁，则进入代码区，同时设置它获得该锁，其他任何线程都将等待它代码的完成，直至它解锁。
[xxx unlockWithCondition:A条件];
表示释放锁，同时把内部的condition设置为A条件

- (void)viewDidLoad {
    [super viewDidLoad];

    [self testLock];
    
}

- (void)testLock {
    
    dispatch_queue_t queue = dispatch_queue_create("com.test.a", DISPATCH_QUEUE_CONCURRENT);
    
    //主线程中
    NSConditionLock *theLock = [[NSConditionLock alloc] init];
    
    //线程1
    dispatch_async(queue, ^{
        for (int i=0;i<=3;i++)
        {
            [theLock lock];
            NSLog(@"thread1:%d",i);
            sleep(1);
            [theLock unlockWithCondition:i];
        }
    });
    
    //线程2
    dispatch_async(queue, ^{
        [theLock lockWhenCondition:2];
        NSLog(@"thread2");
        [theLock unlock];
    });

}

执行结果:

2019-03-09 20:54:59.762199+0800 test[4171:428554] thread1:0
2019-03-09 20:55:00.767031+0800 test[4171:428554] thread1:1
2019-03-09 20:55:01.770958+0800 test[4171:428554] thread1:2
2019-03-09 20:55:02.771687+0800 test[4171:428556] thread2
2019-03-09 20:55:02.772258+0800 test[4171:428554] thread1:3

在线程1中的加锁使用了lock，是不需要条件的，所以顺利的就锁住了。
unlockWithCondition:在开锁的同时设置了一个整型的条件 2 。
线程2则需要一把被标识为2的钥匙，所以当线程1循环到 i = 2 时，线程2的任务才执行。
NSConditionLock也跟其它的锁一样，是需要lock与unlock对应的，只是lock,lockWhenCondition:与unlock，unlockWithCondition:是可以随意组合的

10. @synchronized 关键字加锁，性能较差不推荐使用。内部封装的是pthread_mutex(recursive)，其实是一个递归锁，会根据传入的对象从内部hasmap获取对应的锁。

@synchronized(这里添加一个OC对象，一般使用self) {
需要执行的代码
}
注意点
1. 加锁的代码尽量少
2. 添加的OC对象必须在多个线程中都是同一对象
3. 优点是不需要显式的创建锁对象，便可以实现锁的机制
4. @synchronized块会隐式的添加一个异常处理例程来保护代码，该处理例程会在异常抛出的时候自动的释放互斥锁。所以如果不想让隐式的异常处理例程带来额外的开销，你可以考虑使用锁对象

- (void)viewDidLoad {
    [super viewDidLoad];

    [self testLock];
    
}

- (void)testLock {
    //设置票的数量为5
    _tickets = 5;
    
    dispatch_queue_t queue = dispatch_queue_create("com.test.a", DISPATCH_QUEUE_CONCURRENT);
    
    //线程1
    dispatch_async(queue, ^{
        [self saleTickets];
    });
    
    //线程2
    dispatch_async(queue, ^{
        [self saleTickets];
    });
}

- (void)saleTickets
{
    while (1) {
        @synchronized(self) {
            [NSThread sleepForTimeInterval:1];
            if (_tickets > 0) {
                _tickets--;
                NSLog(@"剩余票数= %ld, Thread:%@",_tickets,[NSThread currentThread]);
            } else {
                NSLog(@"票卖完了  Thread:%@",[NSThread currentThread]);
                break;
            }
        }
    }
}

查看结果:

2019-03-09 11:11:56.351768+0800 test[2452:200838] 剩余票数= 4, Thread:<NSThread: 0x60400046ea00>{number = 3, name = (null)}
2019-03-09 11:11:57.357842+0800 test[2452:200842] 剩余票数= 3, Thread:<NSThread: 0x60000007af40>{number = 4, name = (null)}
2019-03-09 11:11:58.362985+0800 test[2452:200838] 剩余票数= 2, Thread:<NSThread: 0x60400046ea00>{number = 3, name = (null)}
2019-03-09 11:11:59.368940+0800 test[2452:200842] 剩余票数= 1, Thread:<NSThread: 0x60000007af40>{number = 4, name = (null)}
2019-03-09 11:12:00.374592+0800 test[2452:200838] 剩余票数= 0, Thread:<NSThread: 0x60400046ea00>{number = 3, name = (null)}
2019-03-09 11:12:01.375835+0800 test[2452:200842] 票卖完了  Thread:<NSThread: 0x60000007af40>{number = 4, name = (null)}
2019-03-09 11:12:02.380906+0800 test[2452:200838] 票卖完了  Thread:<NSThread: 0x60400046ea00>{number = 3, name = (null)}

二. 读写锁

1. dispatch_barrier_async栏栅函数
#import "ViewController.h"
#import <pthread.h>

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

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];

    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");
}
2. pthread_rwlock_t读写锁
@interface ViewController ()
@property (assign, nonatomic) pthread_rwlock_t lock;
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 初始化锁
    pthread_rwlock_init(&_lock, NULL);
    
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    
    for (int i = 0; i < 10; i++) {
        dispatch_async(queue, ^{
            [self read];
        });
        dispatch_async(queue, ^{
            [self write];
        });
    }
}


- (void)read {
    pthread_rwlock_rdlock(&_lock);
    
    sleep(1);
    NSLog(@"%s", __func__);
    
    pthread_rwlock_unlock(&_lock);
}

- (void)write
{
    pthread_rwlock_wrlock(&_lock);
    
    sleep(1);
    NSLog(@"%s", __func__);
    
    pthread_rwlock_unlock(&_lock);
}

- (void)dealloc
{
    pthread_rwlock_destroy(&_lock);
}

三. 总结

可以看到除了 OSSpinLock 外，os_unfair_lock、dispatch_semaphore 、 pthread_mutex 性能是最高的。

YYKit组件中YYCache 和 YYImageCoder大量使用 dispatch_semaphore pthread_mutex这两个锁

OSSpinLock自旋锁(虽然已经被证明不安全 优先级翻转)，性能最高的锁。原理很简单，就是一直 do while 忙等。它的缺点是当等待时会消耗大量 CPU 资源，所以它不适用于较长时间的任务。对于内存缓存的存取来说，它非常合适。

  1. 等待时间很短的情况下推荐使用os_unfair_lock、dispatch_semaphore 、 pthread_mutex。
  2. 多读单写的时候推荐使用pthread_rwlock_t、dispatch_barrier_async。
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 213,014评论 6赞 492
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 90,796评论 3赞 386
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 158,484评论 0赞 348
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,830评论 1赞 285
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,946评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 50,114评论 1赞 292
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,182评论 3赞 412
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,927评论 0赞 268
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,369评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,678评论 2赞 327
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,832评论 1赞 341
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,533评论 4赞 335
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,166评论 3赞 317
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,885评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,128评论 1赞 267
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,659评论 2赞 362
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,738评论 2赞 351

推荐阅读更多精彩内容

  • iOS中的锁
    锁是一种同步机制，用于多线程环境中对资源访问的限制iOS中常见锁的性能对比图（摘自：ibireme）： iOS锁的...
    LiLS阅读 1,512评论 0赞 6
  • iOS中的锁的介绍及使用
    在平时的开发中经常使用到多线程，在使用多线程的过程中，难免会遇到资源竞争的问题，那我们怎么来避免出现这种问题那？ ...
    IAMCJ阅读 3,092评论 2赞 25
  • iOS开发中的11种锁整理
    本文节选自成长手册 文章推荐和参考深入理解 iOS 开发中的锁pthread的各种同步机制 多线程编程被普遍认为复...
    百草纪阅读 2,801评论 1赞 9
  • iOS - 关于线程同步
    引用自多线程编程指南应用程序里面多个线程的存在引发了多个执行线程安全访问资源的潜在问题。两个线程同时修改同一资源有...
    Mitchell阅读 1,984评论 1赞 7
  • <译>iOS中的同步操作
    翻译：Synchronization 同步 应用程序中存在多个线程会导致潜在的问题，这些问题可能会导致从多个执行线...
    AlexCorleone阅读 2,467评论 0赞 4