多线程+锁-详解

进程和线程

进程

进程是指在系统中正在运行的一个应用程序每个进程之间是独立的，每个进程均运行在其专用且受保护的内存空间内

比如同时打开QQ、Xcode，系统就会分别启动2个进程通过“活动监视器”可以查看Mac系统中所开启的进程

线程

1个进程要想执行任务，必须得有线程（每1个进程至少要有1条线程）线程是进程的基本执行单元，一个进程（程序）的所有任务都在线程中执行比如使用酷狗播放音乐、使用迅雷下载电影，都需要在线程中执行

多线程的优缺点

优点：

能适当提高程序的执行效率

能适当提高资源利用率（CPU、内存利用率）

缺点：

开启线程需要占用一定的内存空间（默认情况下，主线程占用1M，子线程占用512KB），如果开启大量的线程，会占用大量的内存空间，降低程序的性能线程越多，CPU在调度线程上的开销就越大程序设计更加复杂：比如线程之间的通信、多线程的数据共享

iOS中的常见多线程方案

GCD 任务和队列

任务

GCD中有2个用来执行任务的函数

• 用同步的方式执行任务

dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);

queue：队列
block：任务

同步执行（sync）：

同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等待，直到队列里面的任务完成之后再继续执行。

只能在当前线程中执行任务，不具备开启新线程的能力。

• 用异步的方式执行任务

dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

异步执行（async）：

异步添加任务到指定的队列中，它不会做任何等待，可以继续执行任务。

可以在新的线程中执行任务，具备开启新线程的能力。

GCD源码：https://github.com/apple/swift-corelibs-libdispatch

队列

这里的队列指执行任务的等待队列，即用来存放任务的队列。队列是一种特殊的线性表，采用 FIFO（先进先出）的原则，即新任务总是被插入到队列的末尾，而读取任务的时候总是从队列的头部开始读取。每读取一个任务，则从队列中释放一个任务。

GCD的队列可以分为2大类型

• 并发队列（Concurrent Dispatch Queue）
  可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）
  并发功能只有在异步（dispatch_async）函数下才有效
  

注意：并发队列的并发功能只有在异步（dispatch_async）函数下才有效

• 串行队列（Serial Dispatch Queue）
  让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）
  

队列的创建方法/获取方法

可以使用dispatch_queue_create来创建队列，需要传入两个参数，第一个参数表示队列的唯一标识符，用于 DEBUG，可为空，Dispatch Queue 的名称推荐使用应用程序 ID 这种逆序全程域名；第二个参数用来识别是串行队列还是并发队列。DISPATCH_QUEUE_SERIAL表示串行队列，DISPATCH_QUEUE_CONCURRENT表示并发队列。

串行队列的创建方法

dispatch_queue_tqueue= dispatch_queue_create("com.testQueue", DISPATCH_QUEUE_SERIAL);

并发队列的创建方法

dispatch_queue_tqueue= dispatch_queue_create("com.testQueue", DISPATCH_QUEUE_CONCURRENT);

对于串行队列，GCD 提供了的一种特殊的串行队列：**主队列（Main Dispatch Queue）。

所有放在主队列中的任务，都会放到主线程中执行。

主队列的获取方法

dispatch_queue_tqueue= dispatch_get_main_queue();

对于并发队列，GCD 默认提供了全局并发队列（Global Dispatch Queue）。

可以使用dispatch_get_global_queue来获取。需要传入两个参数。第一个参数表示队列优先级，一般用DISPATCH_QUEUE_PRIORITY_DEFAULT。第二个参数暂时没用，用0即可。

全局并发队列的获取方法

dispatch_queue_tqueue= dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);

各种队列的执行效果

使用sync函数往当前串行队列中添加任务，会卡住当前的串行队列（产生死锁）

示例：

// dispatch_sync和dispatch_async用来控制是否要开启新的线程
**************************
主队列原有的任务会执行1和3
dispatch_get_main_queue是串行主队列
block0是dispatch_sync会立马在当前线程执行2，又由于3在2的前面，所以造成死锁   
打印结果 1
**************************
- (void)interview01
{
    NSLog(@"1");
    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_sync(queue, ^{ block0
        NSLog(@"2");
    });
    NSLog(@"3");
}

**************************
主队列原有的任务会执行1和3
block0是dispatch_async不要求立马在当前线程同步执行任务，由于3在2的前面，所以3相较于2先执行
打印结果 1 3 2
**************************
- (void)interview02
{
    NSLog(@"1");
    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_async(queue, ^{block0
        NSLog(@"2");
    });
    NSLog(@"3");
    //dispatch_async不要求立马在当前线程同步执行任务
}
**************************
主队列原有的任务会执行1和5
创建了1个串行队列， block0是dispatch_async开启新的子线程，由于异步任务不要求立马在当前线程同步执行任务，所以执行顺序 1 5 2
block1是dispatch_sync会立马执行3，由于block1和block0是在同一个串行队列中，block0排在block1任务的前面，所以4和3相互等待。
打印结果 1 5 2
**************************
- (void)interview03
{
    // 问题：以下代码是在主线程执行的，会不会产生死锁？会！
    NSLog(@"1");
    dispatch_queue_t queue = dispatch_queue_create("myqueu", DISPATCH_QUEUE_SERIAL);
    dispatch_async(queue, ^{ // block0
        NSLog(@"2");
        dispatch_sync(queue, ^{ // block1
            NSLog(@"3");
        });
        NSLog(@"4");
    });
    NSLog(@"5");
}
**************************
主队列原有的任务会执行1和5
创建了2个串行队列，block0是dispatch_async添加到串行队列（开启了新的子线程）
block1是dispatch_sync在当前线程被添加另外一个串行队列，由于block0和block1属于不同队列，不构成串行关系，所以3不用等待4，不构成思索
打印结果 1 5 2 3 4
**************************
- (void)interview04
{
    // 问题：以下代码是在主线程执行的，会不会产生死锁？不会！
    NSLog(@"1");
    dispatch_queue_t queue = dispatch_queue_create("myqueu", DISPATCH_QUEUE_SERIAL);
//    dispatch_queue_t queue2 = dispatch_queue_create("myqueu2", DISPATCH_QUEUE_CONCURRENT);
    dispatch_queue_t queue2 = dispatch_queue_create("myqueu2", DISPATCH_QUEUE_SERIAL);
    dispatch_async(queue, ^{ // block0
        NSLog(@"2");
        dispatch_sync(queue2, ^{ // block1
            NSLog(@"3");
        });
        NSLog(@"4");
    });
    NSLog(@"5");
}
**************************
主队列原有的任务会执行1和5
创建了一个并发队列，block0异步执行并添加到并发队列（开启了一条子线程）
block1当前子线程同步执行添加到并发队列，由于并发队列可以同步执行，所以3不用等待4
打印结果 1 5 2 3 4
**************************
- (void)interview05
{
    // 问题：以下代码是在主线程执行的，会不会产生死锁？不会！
    NSLog(@"1");
    dispatch_queue_t queue = dispatch_queue_create("myqueu", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{ // block0
        NSLog(@"2");
        dispatch_sync(queue, ^{ // block1
            NSLog(@"3");
        });
        NSLog(@"4");
    });
    NSLog(@"5");
}

- (void)viewDidLoad {
    [super viewDidLoad];
    [self interview01];
}
@end

^{ } 一个block就是一个任务，block内的代码按顺序执行

dispatch_queue_t queue1 = dispatch_get_global_queue(0, 0);
dispatch_queue_t queue2 = dispatch_get_global_queue(0, 0);
dispatch_queue_t queue3 = dispatch_queue_create("queu3", DISPATCH_QUEUE_CONCURRENT);
dispatch_queue_t queue4 = dispatch_queue_create("queu4", DISPATCH_QUEUE_CONCURRENT);
dispatch_queue_t queue5 = dispatch_queue_create("queu5", DISPATCH_QUEUE_CONCURRENT);
NSLog(@"%p %p %p %p %p", queue1, queue2, queue3, queue4, queue5);

0x100a70f00 0x100a70f00 0x28344fa80 0x28344c600 0x28344d200

面试题

请问下面代码的打印结果是什么？

dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
dispatch_async(queue, ^{
        NSLog(@"1");
        // 这句代码的本质是往Runloop中添加定时器
        [self performSelector:@selector(test) withObject:nil afterDelay:.0];
        NSLog(@"3");
        //[[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
    });

- (void)test
{
    NSLog(@"2");
}

打印结果是：1、3
原因:
performSelector:withObject:afterDelay:的本质是往Runloop中添加定时器
子线程默认没有启动Runloop

请问下面代码的打印结果是什么？

 NSThread *thread = [[NSThread alloc] initWithBlock:^{
        NSLog(@"1");
//        [[NSRunLoop currentRunLoop] addPort:[[NSPort alloc] init] forMode:NSDefaultRunLoopMode];
//        [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
    }];
[thread start];
    
[self performSelector:@selector(test) onThread:thread withObject:nil waitUntilDone:YES];

- (void)test
{
    NSLog(@"2");
}

打印结果是：1 并触发崩溃
原因:
在子线程start之后执行block里面的任务，打印1
同时主线程继续执行performSelector，由于子线程的中的block任务执行完之后，子线程的生命周期就结束了，无法在使用，而且thread是局部变量，block任务完成之后就释放掉了
所以出现

reason: '*** -[ViewController performSelector:onThread:withObject:waitUntilDone:modes:]: target thread exited while waiting for the perform'

如果想打印2必须在开启一次RunLoop,保证线程处于激活状态

队列组的使用

需求：
异步并发执行任务1、任务2
等任务1、任务2都执行完毕后，再回到主线程执行任务3

  // 创建队列组
    dispatch_group_t group = dispatch_group_create();
    // 创建并发队列
    dispatch_queue_t queue = dispatch_queue_create("my_queue", DISPATCH_QUEUE_CONCURRENT);
    // 添加异步任务
    dispatch_group_async(group, queue, ^{
        for (int i = 0; i < 5; i++) {
            NSLog(@"任务1-%@", [NSThread currentThread]);
        }
    });
    
    dispatch_group_async(group, queue, ^{
        for (int i = 0; i < 5; i++) {
            NSLog(@"任务2-%@", [NSThread currentThread]);
        }
    });
    
    // 等前面的任务执行完毕后，会自动执行这个任务
    dispatch_group_notify(group, queue, ^{
        dispatch_async(dispatch_get_main_queue(), ^{
            for (int i = 0; i < 5; i++) {
                NSLog(@"任务3-%@", [NSThread currentThread]);
            }
        });
    });

 dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        for (int i = 0; i < 5; i++) {
            NSLog(@"任务1-%@", [NSThread currentThread]);
        }
        dispatch_group_leave(group);
    });

    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        for (int i = 0; i < 5; i++) {
            NSLog(@"任务2-%@", [NSThread currentThread]);
        }
        dispatch_group_leave(group);
    });

    // 等前面的任务执行完毕后，会自动执行这个任务
    dispatch_group_notify(group, queue, ^{
        dispatch_async(dispatch_get_main_queue(), ^{
            for (int i = 0; i < 5; i++) {
                NSLog(@"任务3-%@", [NSThread currentThread]);
            }
        });
    });

多线程的安全隐患

资源共享
1块资源可能会被多个线程共享，也就是多个线程可能会访问同一块资源
比如多个线程访问同一个对象、同一个变量、同一个文件

当多个线程访问同一块资源时，很容易引发数据错乱和数据安全问题

多线程安全隐患示例 – 存钱取钱

@interface ViewController ()
@property (assign, nonatomic) int money;
@end

implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    
    [self moneyTest];
}

/**
 存钱、取钱演示
 */
- (void)moneyTest
{
    self.money = 100;
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    dispatch_async(queue, ^{
        for (int i = 0; i < 10; i++) {
            [self saveMoney];
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 10; i++) {
            [self drawMoney];
        }
    });
}

/**
 存钱
 */
- (void)saveMoney
{
    int oldMoney = self.money;
    sleep(.2);
    oldMoney += 50;
    self.money = oldMoney;
    
    NSLog(@"存50，还剩%d元 - %@", oldMoney, [NSThread currentThread]);
}

/**
 取钱
 */
- (void)drawMoney
{
    int oldMoney = self.money;
    sleep(.2);
    oldMoney -= 20;
    self.money = oldMoney;
    NSLog(@"取20，还剩%d元 - %@", oldMoney, [NSThread currentThread]);
}

@end

多线程安全隐患示例 – 卖票

@interface ViewController ()
@property (assign, nonatomic) int ticketsCount;
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    [self ticketTest];
}

/**
 卖票演示
 */
- (void)ticketTest
{
    self.ticketsCount = 15;
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    dispatch_async(queue, ^{
        for (int i = 0; i < 5; i++) {
             [self saleTicket];
        }
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 5; i++) {
            [self saleTicket];
        }
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 5; i++) {
            [self saleTicket];
        }
    });
}

@end

多线程安全隐患分析

多线程安全隐患的解决方案

解决方案：使用线程同步技术（同步，就是协同步调，按预定的先后次序进行）
常见的线程同步技术是：加锁

iOS中的线程同步方案

1. OSSpinLock

OSSpinLock叫做自旋锁，等待锁的线程会处于忙等（busy-wait）状态，一直占用着CPU资源
目前已经不再安全，可能会出现优先级反转问题
如果等待锁的线程优先级较高，它会一直占用着CPU资源，优先级低的线程就无法释放锁

#import <libkern/OSAtomic.h>

@property (assign, nonatomic) OSSpinLock OSSLock;

- (instancetype)init
{
    if (self = [super init]) {
        //初始化
        self. OSSLock = OS_SPINLOCK_INIT;
    }
    return self;
}

- (void)__lockCode
{
    // 尝试加锁(如果需要等待就不加锁，直接返回false；如果不需要等待就加锁，返回true)
    //OSSpinLockTry(&_OSSLock)
    //加锁
    OSSpinLockLock(&_OSSLock);
    ******************
    要加锁的代码
    ******************
    //解锁
    OSSpinLockUnlock(&_OSSLock);
}
/*
注:苹果爸爸已经在iOS10.0以后废弃了这种锁机制,使用os_unfair_lock 替换,
顾名思义能够保证不同优先级的线程申请锁的时候不会发生优先级反转问题.
*/

2. os_unfair_lock

os_unfair_lock用于取代不安全的OSSpinLock ，从iOS10开始才支持
从底层调用看，等待os_unfair_lock锁的线程会处于休眠状态，并非忙等,所以是互斥锁

#import <os/lock.h>
// 初始化
 os_unfair_lock unfair_lock = OS_UNFAIR_LOCK_INIT;
// 加锁
os_unfair_lock_lock(&unfair_lock);
// 解锁
os_unfair_lock_unlock(&unfair_lock);
// 尝试加锁，可以加锁则立即加锁并返回 YES,反之返回 NO
os_unfair_lock_trylock(&unfair_lock);
/*
注:解决不同优先级的线程申请锁的时候不会发生优先级反转问题.
不过相对于 OSSpinLock , os_unfair_lock性能方面减弱了许多.
*/

3. pthread_mutex

mutex叫做互斥锁，等待锁的线程会处于休眠状态

#import <pthread.h>

@property (assign, nonatomic) pthread_mutex_t mutex;

- (void)__initMutex:(pthread_mutex_t *)mutex
{
    // 静态初始化
    //pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    // 初始化属性
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_DEFAULT);
    // 初始化锁
    pthread_mutex_init(mutex, &attr);
    // 销毁属性
    pthread_mutexattr_destroy(&attr);
}

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

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

pthread_mutex – 递归锁

/*
 * Mutex type attributes
 */
#define PTHREAD_MUTEX_NORMAL        0
#define PTHREAD_MUTEX_ERRORCHECK    1
#define PTHREAD_MUTEX_RECURSIVE     2
#define PTHREAD_MUTEX_DEFAULT       PTHREAD_MUTEX_NORMAL

 // 初始化属性
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
// 初始化锁
pthread_mutex_init(&_mutex, &attr);

- (void)lockTest
{
    pthread_mutex_lock(&_mutex);
    NSLog(@"%s", __func__);
    [self lockTest];
    pthread_mutex_unlock(&_mutex);
}

递归锁:同一条线程可以加多把锁,就是相同的线程访问同一段代码,
如果已经加锁可以继续加锁,不同线程来访问这段代码时,发现有锁要等待所有锁解开之后才可以继续往下走.

pthread_mutex – 条件

#import <pthread.h>

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

@implementation MutexDemo

- (instancetype)init
{
    if (self = [super init]) {
        // 初始化属性
        pthread_mutexattr_t attr;
        pthread_mutexattr_init(&attr);
        pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
        // 初始化锁
        pthread_mutex_init(&_mutex, &attr);
        // 销毁属性
        pthread_mutexattr_destroy(&attr);
        // 初始化条件
        pthread_cond_init(&_cond, NULL);
        self.data = [NSMutableArray array];
    }
    return self;
}

- (void)otherTest
{
    [[[NSThread alloc] initWithTarget:self selector:@selector(__remove) object:nil] start];
    [[[NSThread alloc] initWithTarget:self selector:@selector(__add) object:nil] start];
}

// 生产者-消费者模式
// 线程1
// 删除数组中的元素
- (void)__remove
{
    pthread_mutex_lock(&_mutex);
    NSLog(@"__remove - begin");
    if (self.data.count == 0) {
        // 等待过程放开锁，接收到信号重新加锁
        pthread_cond_wait(&_cond, &_mutex);
    }
    [self.data removeLastObject];
    NSLog(@"删除了元素");
    pthread_mutex_unlock(&_mutex);
}

// 线程2
// 往数组中添加元素
- (void)__add
{
    pthread_mutex_lock(&_mutex);
    sleep(1);
    [self.data addObject:@"Test"];
    NSLog(@"添加了元素");
    // 信号
    pthread_cond_signal(&_cond);
    // 广播
//    pthread_cond_broadcast(&_cond);
    pthread_mutex_unlock(&_mutex);
}

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

@end

4. dispatch_semaphore

semaphore叫做”信号量”
信号量的初始值，可以用来控制线程并发访问的最大数量
信号量的初始值为1，代表同时只允许1条线程访问资源，保证线程同步

@interface SemaphoreDemo()
@property (strong, nonatomic) dispatch_semaphore_t semaphore;
@end

@implementation SemaphoreDemo

- (instancetype)init
{
    if (self = [super init]) {
        self.semaphore = dispatch_semaphore_create(1);
    }
    return self;
}

- (void)__saleTicket
{
    // 如果信号量的值 > 0，就让信号量的值减1，然后继续往下执行代码
    // 如果信号量的值 <= 0，就会休眠等待，直到信号量的值变成>0，就让信号量的值减1，然后继续往下执行代码
    dispatch_semaphore_wait(self.ticketSemaphore, DISPATCH_TIME_FOREVER);
    ****************************
    要加锁的代码
    ****************************
 // 让信号量的值+1
    dispatch_semaphore_signal(self.ticketSemaphore);
}

5. dispatch_queue(DISPATCH_QUEUE_SERIAL)

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

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

@implementation SerialQueueDemo

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

- (void)__lockTest
{
    dispatch_sync(self.queue, ^{
        **************************
        do something
        **************************
    });
}

@end

保证线程按照顺序执行

6. NSLock

NSLock是对mutex普通锁的封装

// 初始化
NSLock *_lock = [[NSLock alloc] init];
// 加锁
[_lock lock];
// 解锁
[_lock unlock];
// 尝试加锁，可以加锁则立即加锁并返回 YES,反之返回 NO
[_lock tryLock];
//触发锁 在等待时间之内
- (BOOL)lockBeforeDate:(NSDate *)limit;

7. NSRecursiveLock

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

8. NSCondition

NSCondition是对mutex和cond的封装

@interface NSCondition : NSObject <NSLocking> {
- (void)wait;
- (BOOL)waitUntilDate:(NSDate *)limit;
- (void)signal;
- (void)broadcast;

9. NSConditionLock

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

@interface NSConditionLock : NSObject <NSLocking> 
- (instancetype)initWithCondition:(NSInteger)condition NS_DESIGNATED_INITIALIZER;

@property (readonly) NSInteger condition;
- (void)lockWhenCondition:(NSInteger)condition;
- (BOOL)tryLock;
- (BOOL)tryLockWhenCondition:(NSInteger)condition;
- (void)unlockWithCondition:(NSInteger)condition;
- (BOOL)lockBeforeDate:(NSDate *)limit;
- (BOOL)lockWhenCondition:(NSInteger)condition beforeDate:(NSDate *)limit;

示例：

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

@implementation NSConditionLockDemo

- (instancetype)init
{
    if (self = [super init]) {
        self.conditionLock = [[NSConditionLock alloc] initWithCondition:1];
    }
    return self;
}

- (void)otherTest
{
    [[[NSThread alloc] initWithTarget:self selector:@selector(__one) object:nil] start];
    [[[NSThread alloc] initWithTarget:self selector:@selector(__two) object:nil] start];
    [[[NSThread alloc] initWithTarget:self selector:@selector(__three) object:nil] start];
}

- (void)__one
{
    [self.conditionLock lockWhenCondition:1];
    NSLog(@"__one");
    [self.conditionLock unlockWithCondition:2];
}

- (void)__two
{
    [self.conditionLock lockWhenCondition:2];
    NSLog(@"__two");
    [self.conditionLock unlockWithCondition:3];
}

- (void)__three
{
    [self.conditionLock lockWhenCondition:3];
    NSLog(@"__three");
    [self.conditionLock unlock];
}

@end

10. @synchronized

@synchronized是对mutex递归锁的封装
源码查看：objc4中的objc-sync.mm文件
@synchronized(obj)内部会生成obj对应的递归锁，然后进行加锁、解锁操作

 @synchronized(obj) { //objc_sync_enter
       任务
  } // objc_sync_exit

int objc_sync_enter(id obj)
{
    if (obj) {
        SyncData* data = id2data(obj, ACQUIRE);
        ASSERT(data);
        data->mutex.lock();
    } 
    ....
    return result;
}

int objc_sync_exit(id obj)
{
    if (obj) {
        SyncData* data = id2data(obj, RELEASE); 
        if (!data) {
            result = OBJC_SYNC_NOT_OWNING_THREAD_ERROR;
        } 
     .....
     return result;
}

iOS线程同步方案性能比较

性能从高到低排序

• os_unfair_lock
• OSSpinLock
• dispatch_semaphore
• pthread_mutex
• dispatch_queue(DISPATCH_QUEUE_SERIAL)
• NSLock
• NSCondition
• pthread_mutex(recursive)
• NSRecursiveLock
• NSConditionLock
• @synchronized

下面是ibireme大神在单线程下对锁的性能测试，里面有demo，大家可以参考一下

自旋锁、互斥锁比较

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

• 预计线程等待锁的时间很短
• 加锁的代码（临界区）经常被调用，但竞争情况很少发生
• CPU资源不紧张
• 多核处理器

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

• 预计线程等待锁的时间较长
• 单核处理器
• 临界区有IO操作
• 临界区代码复杂或者循环量大
• 临界区竞争非常激烈

atomic

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

void objc_setProperty(id self, SEL _cmd, ptrdiff_t offset, id newValue, BOOL atomic, signed char shouldCopy) 
{
    .....
    reallySetProperty(self, _cmd, newValue, offset, atomic, copy, mutableCopy);
}

static inline void reallySetProperty(id self, SEL _cmd, id newValue, ptrdiff_t offset, bool atomic, bool copy, bool mutableCopy)
{
   ...
    if (!atomic) {
        oldValue = *slot;
        *slot = newValue;
    } else {
        spinlock_t& slotlock = PropertyLocks[slot];
        slotlock.lock();
        oldValue = *slot;
        *slot = newValue;        
        slotlock.unlock();
    }
    ...
}

id objc_getProperty(id self, SEL _cmd, ptrdiff_t offset, BOOL atomic) {
 ......
    if (!atomic) return *slot;
    // Atomic retain release world
    spinlock_t& slotlock = PropertyLocks[slot];
    slotlock.lock();
    id value = objc_retain(*slot);
    slotlock.unlock();
......
}

@property (strong, atomic) NSMutableArray *arr;
[arr addObject:@"1"];
[arr removeObject:@"1"];

可变arr的添加和删除并没有加锁

iOS中的读写安全方案

思考如何实现以下场景？
同一时间，只能有1个线程进行写的操作
同一时间，允许有多个线程进行读的操作
同一时间，不允许既有写的操作，又有读的操作

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

• pthread_rwlock：读写锁

#import <pthread.h>
@property (assign, nonatomic) pthread_rwlock_t lock;
// 初始化锁
pthread_rwlock_init(&_lock, NULL);

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

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

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

• dispatch_barrier_async：异步栅栏调用
  

@property (strong, nonatomic) dispatch_queue_t queue;

self.queue = dispatch_queue_create("rw_queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(self.queue, ^{
      [self read];
 });
        
dispatch_barrier_async(self.queue, ^{
      [self write];
});

这个函数传入的并发队列必须是自己通过dispatch_queue_cretate创建的
如果传入的是一个串行或是一个全局的并发队列，那这个函数便等同于dispatch_async函数的效果

GNUstep

GNUstep是GNU计划的项目之一，它将Cocoa的OC库重新开源实现了一遍
源码地址：http://www.gnustep.org/resources/downloads.php
虽然GNUstep不是苹果官方源码，但还是具有一定的参考价值