不可描述的 iOS 锁事

// Begin synchronizing on 'obj'. 
// Allocates recursive mutex associated with 'obj' if needed.
// Returns OBJC_SYNC_SUCCESS once lock is acquired.  
int objc_sync_enter(id obj)
{
    int result = OBJC_SYNC_SUCCESS;

    if (obj) {
        SyncData* data = id2data(obj, ACQUIRE);
        assert(data);
        data->mutex.lock();
    } else {
        // @synchronized(nil) does nothing
        if (DebugNilSync) {
            _objc_inform("NIL SYNC DEBUG: @synchronized(nil); set a breakpoint on objc_sync_nil to debug");
        }
        objc_sync_nil();
    }

    return result;
}

// End synchronizing on 'obj'. 
// Returns OBJC_SYNC_SUCCESS or OBJC_SYNC_NOT_OWNING_THREAD_ERROR
int objc_sync_exit(id obj)
{
    int result = OBJC_SYNC_SUCCESS;
    
    if (obj) {
        SyncData* data = id2data(obj, RELEASE); 
        if (!data) {
            result = OBJC_SYNC_NOT_OWNING_THREAD_ERROR;
        } else {
            bool okay = data->mutex.tryUnlock();
            if (!okay) {
                result = OBJC_SYNC_NOT_OWNING_THREAD_ERROR;
            }
        }
    } else {
        // @synchronized(nil) does nothing
    }
    return result;
}

#include <pthread.h>

+(id)fooFerBar:(id)bar {
   static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
   if (pthread_mutex_lock(&mtx)) {
      printf("lock failed sigh...");
      exit(-1);
}
   static NSDictionary *foo = nil;
   if (!foo) foo = [NSDictionary dictionaryWithObjects:...];
   if (pthread_mutex_unlock(&mtx) != 0)) {
      printf("unlock failed sigh...");
      exit(-1);
}
   return [foo objectWithKey:bar];
}

@synchronized (sharedToken) {
    [arrA addObject:obj];
}
@synchronized (sharedToken) {
    [arrB addObject:obj];
}

@synchronized (tokenA) {
    [arrA addObject:obj];
}
@synchronized (tokenB) {
    [arrB addObject:obj];
}

@synchronized (tokenA) {
    [arrA addObject:obj];
    [self doSomethingWithA:arrA];
}

@protocol NSLocking

- (void)lock;
- (void)unlock;

// _cpuUsageLock是一个私有字段，也可以是一个属性
- (NSArray *)cpuUsagePerProcessor {
    // 初始化锁
    _cpuUsageLock = [[NSLock alloc] init];
    [_cpuUsageLock lock];
    // TODO: 线程安全代码
    [_cpuUsageLock unlock];//释放锁标记着临界区的结束。其他线程就可以获取锁了
}

- (instancetype)init
{
    self = [super init];
    if (self) {
        _lock = [NSRecursiveLock new];
    }
    return self;
}
- (void)threadSafeMethod1
{
    [_lock lock];
    //threadSafe code
    [self threadSafeMethod2];
    [_lock unlock];
}
- (void)threadSafeMethod2
{
    [_lock lock];
//    threadSafe code
    [_lock unlock];
}

- (id)firstOrDefault:(id)defaultValue success:(BOOL *)success error:(NSError **)error {
	NSCondition *condition = [[NSCondition alloc] init];
	condition.name = [NSString stringWithFormat:@"[%@] -firstOrDefault: %@ success:error:", self.name, defaultValue];

	__block id value = defaultValue;
	__block BOOL done = NO;

	// Ensures that we don't pass values across thread boundaries by reference.
	__block NSError *localError;
	__block BOOL localSuccess;

	[[self take:1] subscribeNext:^(id x) {
		[condition lock];

		value = x;
		localSuccess = YES;

		done = YES;
		[condition broadcast];
		[condition unlock];
	} error:^(NSError *e) {
		[condition lock];

		if (!done) {
			localSuccess = NO;
			localError = e;
			done = YES;
			[condition broadcast];
		}
		[condition unlock];
	} completed:^{
		[condition lock];
		localSuccess = YES;
		done = YES;
		[condition broadcast];
		[condition unlock];
	}];

	[condition lock];
	while (!done) {
		[condition wait];
	}
	if (success != NULL) *success = localSuccess;
	if (error != NULL) *error = localError;
	[condition unlock];
	return value;
}

// 用于condition等于特定值的时候获取锁，会阻塞当前线程。
- (void)lockWhenCondition:(NSInteger)condition;

// 尝试获取锁，获取锁失败时返回NO，try开头的方法会理解解锁。
- (BOOL)tryLock;
- (BOOL)tryLockWhenCondition:(NSInteger)condition;

// 指定条件时解锁，每次解锁会导致内部的condition值改变为指定的值，同时唤醒其它阻塞的线程检测这里的condition是否满足条件，因此NSConditionLock相对于NSCondition效率更低。
- (void)unlockWithCondition:(NSInteger)condition;

// 指定条件获取锁，会阻塞当前线程。
- (BOOL)lockBeforeDate:(NSDate *)limit;
- (BOOL)lockWhenCondition:(NSInteger)condition beforeDate:(NSDate *)limit;

/*
 Mutex type attributes
*/
// 缺省类型，也就是普通锁。当一个线程加锁以后，其余请求锁的线程将形成一个等待队列，并在解锁后先进先出原则获得锁。
#define PTHREAD_MUTEX_NORMAL        0
// 检错锁，如果同一个线程请求同一个锁，则返回 EDEADLK，否则与普通锁类型动作相同。这样就保证当不允许多次加锁时不会出现嵌套情况下的死锁。
#define PTHREAD_MUTEX_ERRORCHECK    1
// 递归锁，允许同一个线程对同一个锁成功获得多次，并通过多次 unlock 解锁。
#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_NORMAL); 

pthread_mutex_t _lock
// 第二个参数是pthread_mutexattr_t的指针，一般填NULL(即为缺省值)，也可以填&attr
pthread_mutex_init(&_lock, NULL); //创建锁
// 返回0即为成功，失败返回错误码
pthread_mutex_trylock(&_lock) // 尝试获取锁

pthread_mutex_lock(&_lock); // 获取锁
// 线程安全代码
pthread_mutex_unlock(&_lock) // 释放锁

// 一般在delloc方法里面销毁
pthread_mutex_destroy(&_lock); // 销毁锁
pthread_mutexattr_destroy(&attr);

// 内存缓存 weakCache  -- NSMapTable
#define LOCK(lock) dispatch_semaphore_wait(lock, DISPATCH_TIME_FOREVER);
#define UNLOCK(lock) dispatch_semaphore_signal(lock);

self.weakCacheLock = dispatch_semaphore_create(1);

LOCK(self.weakCacheLock);
[self.weakCache setObject:obj forKey:key];
UNLOCK(self.weakCacheLock);

os_unfair_lock_t unfairLock;
unfairLock = &(OS_UNFAIR_LOCK_INIT);
os_unfair_lock_lock(unfairLock);
os_unfair_lock_unlock(unfairLock);

// 初始化锁
pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER

pthread_rwlock_rdlock(&rwlock);//加读锁
// 临界区
pthread_rwlock_unlock(&rwlock);//解锁


pthread_rwlock_wrlock(&rwlock);//加写锁
// 临界区
pthread_rwlock_unlock(&rwlock);//解锁