简介

自旋锁：在访问被锁资源时，调用者线程不会休眠，而是不停循环在那里，直到被锁资源释放锁。
互斥锁：在访问被锁资源时，调用者线程会休眠，此时cpu可以调度其他线程工作。直到被锁资源释放锁。此时会唤醒休眠线程。

优缺点：
　　自旋锁的优点在于，因为自旋锁不会引起调用者睡眠，所以不会进行线程调度，cpu时间片轮转等耗时操作。所有如果能在很短的时间内获得锁，自旋锁的效率远高于互斥锁。
　　缺点在于，自旋锁一直占用CPU，他在未获得锁的情况下，一直运行－－自旋，所以占用着CPU，如果不能在很短的时 间内获得锁，这无疑会使CPU效率降低。自旋锁不能实现递归调用。

常用锁

• dispatch_semaphore_t

 dispatch_semaphore_t semphorelock = dispatch_semaphore_create(1);
//加锁
 dispatch_semaphore_wait(semphorelock,DISPATCH_TIME_FOREVER);
//解锁
 dispatch_semaphore_signal(semphorelock);

• os_unfair_lock

  os_unfair_lock unfairlock = OS_UNFAIR_LOCK_INIT;
//加锁
 os_unfair_lock_lock(&unfairlock);
//解锁
 os_unfair_lock_unlock(&unfairlock);

• pthread_mutex_t

  pthread_mutex_t mutexlock = PTHREAD_MUTEX_INITIALIZER;
//加锁
pthread_mutex_lock(&mutexlock);
//解锁
 pthread_mutex_unlock(&mutexlock);

• NSCondition

NSCondition *condition = [[NSCondition alloc] init];
//加锁
[condition lock];
//解锁
 [condition unlock];

• NSLock

NSLock *lock = [[NSLock alloc] init];
//加锁
[lock lock];
//解锁
 [lock unlock];

• pthread_mutex_t（rescurisive）

pthread_mutex_t mutex_t;
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); pthread_mutex_init(&mutex_t, &attr);
//加锁
 pthread_mutex_lock(&mutex_t);
//解锁
  pthread_mutex_unlock(&mutex_t);

• NSRecursiveLock

NSRecursiveLock *rescurisivelock = [[NSRecursiveLock alloc] init];
//加锁
[rescurisivelock lock];
//解锁
 [rescurisivelock unlock];

• NSConditionLock

NSConditionLock *conditionlock = [[NSConditionLock alloc] init];
//加锁
[conditionlock lock];
//解锁
 [conditionlock unlock];

• @synchronized

@synchronized (condition) {
            
  }

NSRecursiveLock和pthread_mutex_t（rescurisive）是自旋锁，其他都是互斥锁。由于OSSpinLock因优先级反转的问题，已经不安全，所以不介绍了。

由于高级锁（NSLock等对象锁）是基于pthread_mutex_t定制，性能方面会有丢失，推荐使用pthread_mutex或者dispatch_semaphore。