当我们涉及多线程开发时就必然涉及线程间的数据安全问题。iOS中线程同步技术的方案之一就是给数据上锁。线程锁有很多种，如下所示：
os_unfair_lock
pthread_mutex
dispatch_semaphore
dispatch_queue(DISPATCH_QUEUE_SERIAL)
NSLock
NSRecursiveLock
NSCondition
NSConditionLock
@synchronized
1.os_unfair_lock
导入头文件
#import <os/lock.h>
用法如下：
//创建锁
os_unfair_lock lock = OS_UNFAIR_LOCK_INIT;
//尝试加锁，添加成功返回true，添加失败返回false
bool r = os_unfair_lock_trylock(&lock);
//强制加锁
os_unfair_lock_lock(&lock);
// 解锁
os_unfair_lock_unlock(&lock);
其中os_unfair_lock_trylock方法与os_unfair_lock_lock方法，我们使用一个加锁即可。
2.pthread_mutex
导入头文件
#import <pthread/pthread.h>
用法如下：
//创建锁属性，也可不设置锁属性
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
/*
* 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_MUTEX_RECURSIVE设置为该属性时，为递归锁，在递归函数中使用，保证递归函数调用仅一个线程
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
//创建锁
pthread_mutex_t mutexLock;
//可设置属性
// pthread_mutex_init(&mutexLock, &attr);
pthread_mutex_init(&mutexLock, NULL);
//尝试加锁，返回1代表加锁成功
// int r = pthread_mutex_trylock(&mutexLock);
//强制加锁
pthread_mutex_lock(&mutexLock);
// 解锁
pthread_mutex_unlock(&mutexLock);
//销毁锁
pthread_mutexattr_destroy(&attr);
pthread_mutex_destroy(&mutexLock);
pthread_mutex也可以创建条件锁，当我们遇到以下情况时可以使用条件锁：
开始执行任务1和任务2，但是任务1依赖于任务2，必须任务2执行完毕才执行任务1，我们可以在任务1前增加条件锁，在任务2完成后打开条件锁，就满足我们的业务开发需求。
相关代码方法如下：
//创建锁
pthread_mutex_t mutexLock;
//可设置属性
pthread_mutex_init(&mutexLock, NULL);
//初始化条件
pthread_cond_t cond;
pthread_cond_init(&cond, NULL);
//进入休眠，等待唤醒
pthread_cond_wait(&self->_cond, &self->_mutexLock);
//激活所有等待该条件的线程
// pthread_cond_broadcast(&self->_cond);
//激活一个等待该条件的线程
pthread_cond_signal(&self->_cond);
//销毁资源
pthread_mutex_destroy(&(self->_mutexLock));
pthread_cond_destroy(&self->_cond);
3.dispatch_semaphore
信号量的使用
GCD提供了信号量函数，提供我们进行线程安全操作，当信号量为0时等待操作，信号量大于0是，继续执行操作，，主要流程如下：
1、创建信号量对象，确定信号初始值
2、开始执行操作前检查是否需要等待，执行函数dispatch_semaphore_wait，如果当前的信号量为0则阻塞，等待信号量大于0时继续执行，执行函数完毕会使信号量减一。当一个任务执行完毕时我们需要调用dispatch_semaphore_signal函数，告诉系统一个任务执行完毕，调用后会使信号量加1。dispatch_semaphore_wait和dispatch_semaphore_signal函数应当成对存在，有特别需求也可以不成对存在。当初始信号量为1时，我们可以用作线程安全锁进行使用，代码如下：
- (void)dispatch_semaphore {
dispatch_semaphore_t semaphore_t = dispatch_semaphore_create(3);
for (int i = 0; i < 10; i++) {
dispatch_semaphore_wait(semaphore_t, DISPATCH_TIME_FOREVER);
dispatch_async(self.concurrent_queue, ^{
int t = rand() % 5;
sleep(t);
NSLog(@"dispatch_semaphore===%d===%@===%d",i,[NSThread currentThread],t);
dispatch_semaphore_signal(semaphore_t);
});
}
NSLog(@"end");
}
4.dispatch_queue
创建串形队列相当于加上了安全锁
代码如下
dispatch_queue_create("", DISPATCH_QUEUE_SERIAL)
5.NSLock
NSLock是对mutex的面相对象封装，使用比较简单。
代码如下：
//创建对象
NSLock *lock = [[NSLock alloc] init];
//上锁
[lock lock]
//解锁
[lock unlock];
6.NSRecursiveLock
NSRecursiveLock是mutex递归锁的面向对象封装，使用简单。代码如下：
//创建对象
NSRecursiveLock* lock = [[NSRecursiveLock alloc] init];
//上锁
[lock lock];
//解锁
[lock unlock];
7.NSCondition
NSCondition是对mutex和cond的封装，代码如下：
//创建对象
NSCondition *condition = [[NSCondition alloc] init];
//激活所有等待该条件的线程
//[self.condition broadcast];
//激活一个等待该条件的线程
[self.condition signal];
//进入休眠，等待唤醒
[self.condition wait];
8.NSConditionLock
NSConditionLock是对NSCondition的进一步封装，可以设置具体的条件值。用法如下：
//创建条件2的锁
NSConditionLock *lock = [[NSConditionLock alloc] initWithCondition:2];
self.conditionLock = lock;
dispatch_async(dispatch_get_global_queue(0, 0), ^{
//等待条件1
[self.conditionLock lockWhenCondition:1];
NSLog(@"1");
//打开条件3
[self.conditionLock unlockWithCondition:3];
});
dispatch_async(dispatch_get_global_queue(0, 0), ^{
//等待条件4
[self.conditionLock lockWhenCondition:4];
NSLog(@"2");
//打开条件1
[self.conditionLock unlockWithCondition:1];
});
dispatch_async(dispatch_get_global_queue(0, 0), ^{
//等待条件2
[self.conditionLock lockWhenCondition:2];
NSLog(@"3");
//打开条件4
[self.conditionLock unlockWithCondition:4];
});
打印顺序为3、2、1
9.synchronized
synchronized使用很简单，把代码写在大括号里面就行。
@synchronized (<#token#>) {
<#statements#>
}
例如：
@synchronized (self) {
self.count = self.count + 1;
}
