自旋锁 与 互斥锁
自旋锁 (spin lock): 如果一个线程需要获取自旋锁，该锁已经被其他线程占用，该线程不会被挂起，而是不断消耗CPU时间，一直试图获取自旋锁。
-
互斥锁 (mutex)：如果一个线程无法获取互斥量，该线程会被直接挂起，不再小号CPU时间，当其他线程释放互斥量后，操作系统会激活被挂起的线程。
使用场景：
多核处理器：如果预计线程等待锁的时间比较短，短到比线程两次切换上下文的时间还要少的情况下，自旋锁是更好的选择。如果时间比较长，则互斥锁是比较好的选择。
-
单核处理器：一般不建议使用自旋锁。因为在同一时间片内只有一个线程处在运行状态，如果线程a已经获取到锁，但是此时时间片轮到线程b执行，但是线程b获取锁，只能等待解锁，但是因为自己不挂起，所以线程a无法进入运行状态，只能等到线程b的时间片消耗完，线程a才有机会被OS调度执行。此时使用自旋锁的代价很高。
如果加锁的代码经常被调用，但是竞争发生的比较少时，应该优先考虑使用自旋锁，毕竟互斥锁的切换上下文的开销比较大。
性能对比
iOS中的锁包括：
- @synchronized
- NSLock
- NSCondition
- NSConditionLock
- NSRecursiveLock
- pthread_mutex_t
- dispatch_semaphore_t
- OSSpinLock
做的测试是对每种锁进行100万次的加锁解锁操作，对比时间，使用的iPhone6的iOS10.1.1的设备，测试结果如下：
各种锁的时间性能对比
从对比可以看出，性能最优的是OSSpinLock ,最差的是@synchronized，下面是我制作的各种锁的性能对比，不同的系统和设备的数值可能会有差异：
iOS中各种锁的性能对比
<h3 align = "center">测试代码</h3>
<a name="fenced-code-block">@synchronized()</a>
CFTimeInterval timeBefore;
CFTimeInterval timeCurrent;
NSUInteger i;
NSUInteger count = 1000*10000;//执行一千万次
//@synchronized
id obj = [[NSObject alloc]init];;
timeBefore = CFAbsoluteTimeGetCurrent();
for(i=0; i<count; i++){
@synchronized(obj){
}
}
timeCurrent = CFAbsoluteTimeGetCurrent();
printf("@synchronized : %f\n", timeCurrent-timeBefore);
<a name="fenced-code-block">NSLock</a>
NSLock *lock = [[NSLock alloc]init];
timeBefore = CFAbsoluteTimeGetCurrent();
for(i=0; i<count; i++){
[lock lock];
[lock unlock];
}
timeCurrent = CFAbsoluteTimeGetCurrent();
printf("NSLock : %f\n", timeCurrent-timeBefore);
<a name="fenced-code-block">NSCondition</a>
NSCondition *condition = [[NSCondition alloc]init];
timeBefore = CFAbsoluteTimeGetCurrent();
for(i=0; i<count; i++){
[condition lock];
[condition unlock];
}
timeCurrent = CFAbsoluteTimeGetCurrent();
printf("NSCondition : %f\n", timeCurrent-timeBefore);
<a name="fenced-code-block">NSConditionLock</a>
NSConditionLock *conditionLock = [[NSConditionLock alloc]init];
timeBefore = CFAbsoluteTimeGetCurrent();
for(i=0; i<count; i++){
[conditionLock lock];
[conditionLock unlock];
}
timeCurrent = CFAbsoluteTimeGetCurrent();
printf("NSConditionLock : %f\n", timeCurrent-timeBefore);
<a name="fenced-code-block">NSRecursiveLock</a>
NSRecursiveLock *recursiveLock = [[NSRecursiveLock alloc]init];
timeBefore = CFAbsoluteTimeGetCurrent();
for(i=0; i<count; i++){
[recursiveLock lock];
[recursiveLock unlock];
}
timeCurrent = CFAbsoluteTimeGetCurrent();
printf("NSRecursiveLock : %f\n", timeCurrent-timeBefore);
<a name="fenced-code-block">pthread_mutex_t</a>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
timeBefore = CFAbsoluteTimeGetCurrent();
for(i=0; i<count; i++){
pthread_mutex_lock(&mutex);
pthread_mutex_unlock(&mutex);
}
timeCurrent = CFAbsoluteTimeGetCurrent();
printf("pthread_mutex : %f\n", timeCurrent-timeBefore);
<a name="fenced-code-block">dispatch_semaphore_t</a>
dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
timeBefore = CFAbsoluteTimeGetCurrent();
for(i=0; i<count; i++){
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
dispatch_semaphore_signal(semaphore);
}
timeCurrent = CFAbsoluteTimeGetCurrent();
printf("dispatch_semaphore : %f\n", timeCurrent-timeBefore);
<a name="fenced-code-block">OSSpinLock</a>
OSSpinLock spinlock = OS_SPINLOCK_INIT;
timeBefore = CFAbsoluteTimeGetCurrent();
for(i=0; i<count; i++){
OSSpinLockLock(&spinlock);
OSSpinLockUnlock(&spinlock);
}
timeCurrent = CFAbsoluteTimeGetCurrent();
printf("OSSpinLock : %f\n", timeCurrent-timeBefore);
