原子操作
在多线程要操作一个字符串时，为了保证只有一个线程在赋值或者取值的时候我们会考虑加锁。
- atomic属性内部的锁称为 自旋锁
- 凡是线程安全的对象，内部肯定会加锁
@property(atomic,copy)NSString *name;
那么atomic是应该怎么在setter和getter中实现呢，原理是仅需要给self加锁，重写setter，getter：
@synthesize name = _name;
- (void)setName:(NSString *)name {
@synchronized(self) {
_name = [name copy];
}
}
- (NSString *)name {
@synchronized(self) {
return _name;
}
}
不过这么写，也不能保证线程安全。如果线程A调用了getter，同时线程B调用了setter，那么A线程getter得到的值，可能是B在set之前的原始值，也可能是B set的值。同时这个属性的值，也可能是B set的值。
所以，保证数据完整性不能简单靠一把锁来完成，毕竟这个是多线程编程最大的难点。
自旋锁和互斥锁
- 相同点：
- 都能保证同一时间只有一个线程访问共享资源。都能保证线程安全。
- 不同点：
- 互斥锁：如果共享数据已经有其他线程加锁了，线程会进入休眠状态等待锁。一旦被访问的资源被解锁，则等待资源的线程会被唤醒。
- 自旋锁：如果共享数据已经有其他线程加锁了，线程会以死循环的方式等待锁，一旦被访问的资源被解锁，则等待资源的线程会立即执行。
- 自旋锁的效率高于互斥锁。
1.信号量 dispatch_semaphore
YY大神推荐使用信号量dispatch_semaphore作为自旋锁的替代方案。
dispatch_semaphore_t signal = dispatch_semaphore_create(1);
dispatch_time_t timeout = dispatch_time(DISPATCH_TIME_NOW, 5.0f * NSEC_PER_SEC);
//线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSLog(@"线程1 holding");
dispatch_semaphore_wait(signal, timeout); //signal 值 -1
NSLog(@"线程1 sleep");
sleep(4);
NSLog(@"线程1");
dispatch_semaphore_signal(signal); //signal 值 +1
NSLog(@"线程1 post singal");
});
//线程2
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSLog(@"线程2 holding");
dispatch_semaphore_wait(signal, timeout);
NSLog(@"线程2 sleep");
sleep(4);
NSLog(@"线程2");
dispatch_semaphore_signal(signal);
NSLog(@"线程2 post signal");
});
dispatch_semaphore_create(1)为创建信号，（）中数字表示可以同时几个线程使用信号。为1表示同步使用。上述代码如果此处标2就和没设置信号量一样，并发自行运行。如果设置为0，则一律等待overTime时自动释放，所有代码都不执行，理论上也具有同步作用。
dispatch_semaphore_wait中传入的timeout表示最长加锁时间，自动释放锁后，其它线程可以获取信号并继续运行。
2.pthread_mutex锁
pthread表示的是POSIX thread，定义的是一组跨平台线程相关的API。
pthread_mutex互斥锁是一个非递归锁，如果同一线程重复调用加锁会造成死锁。
用法比较简单
static pthread_mutex_t pmutexLock;
pthread_mutex_init(&pLock, NULL);
//1.线程2
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
NSLog(@"线程2 befor lock");
pthread_mutex_lock(&pLock);
NSLog(@"线程2");
pthread_mutex_unlock(&pLock);
});
//2.线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSLog(@"线程1 before lock");
pthread_mutex_lock(&pLock);
sleep(3);
NSLog(@"线程1");
pthread_mutex_unlock(&pLock);
});
pthread_mutex(recursive) 递归锁，比较安全，同一线程有且仅有一次加锁，重复加锁不会死锁。无论加锁几次，只需解锁一次。
static pthread_mutex_t pLock;
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr); //初始化attr赋初值
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); //设置锁类型为递归锁
pthread_mutex_init(&pLock, &attr);
pthread_mutexattr_destroy(&attr);
//1.线程1
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
static void (^RecursiveBlock)(int);
RecursiveBlock = ^(int value) {
pthread_mutex_lock(&pLock);
if (value > 0) {
NSLog(@"value: %d", value);
RecursiveBlock(value - 1);
}
};
NSLog(@"线程1 before lock");
RecursiveBlock(5);
NSLog(@"线程1");
pthread_mutex_unlock(&pLock);
NSLog(@"线程1 unlock");
});
//2.线程2
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSLog(@"线程2 before lock");
pthread_mutex_lock(&pLock);
NSLog(@"线程2");
pthread_mutex_unlock(&pLock);
NSLog(@"线程2 unlock");
});
3.@synchronized
@synchronized 实际上是把修饰对象当做锁来使用。这是通过一个哈希表来实现的，OC 在底层使用了一个互斥锁的数组(你可以理解为锁池)，通过对对象去哈希值来得到对应的互斥锁。
各种锁的性能参考下YY大神的图
相同类型的锁递归锁和普通锁效率相差接近一倍，如果不会在循环或者递归中频繁使用加锁和解锁，不建议使用递归锁；从效率上讲，建议用互斥锁pthread_mutex（YYKit方案）或者信号量dispatch_semaphore作为替代。
OSSpinlock各路大神都说有问题，还有iOS的各种锁就不一一细说了，如果想了解更多的线程锁自行去搜索哈。
