多线程

// 不使用队列组的实现，比较凌乱
dispatch_async(dispatch_get_global_queue(0, 0), ^{
    dispatch_sync(dispatch_get_global_queue(0, 0), ^{
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            for (int i=0; i < 10; i++)
            {
                NSLog(@"Misson: 1, %@", [NSThread currentThread]);
            }
        });
        
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            for (int i=0; i < 10; i++)
            {
                NSLog(@"Misson: 2, %@", [NSThread currentThread]);
            }
        });
    });
    
    dispatch_async(dispatch_get_main_queue(), ^{
        for (int i=0; i < 10; i++)
        {
            NSLog(@"Misson: 3, %@", [NSThread currentThread]);
        }
     });
});

// 使用队列组
dispatch_group_t group = dispatch_group_create();
dispatch_queue_t queue = dispatch_queue_create(0,DISPATCH_QUEUE_CONCURRENT);

// 异步并发执行加到group中的block代码
dispatch_group_async(group, queue, ^{
    for (int i=0; i < 10; i++)
    {
        NSLog(@"Misson: 1, %@", [NSThread currentThread]);
    }
});

dispatch_group_async(group, queue, ^{
    for (int i=0; i < 10; i++)
    {
        NSLog(@"Misson: 2, %@", [NSThread currentThread]);
    }
});


// 等group中的所有任务执行完之后通知执行下面的代码，也是async的
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
    for (int i=0; i < 10; i++)
    {
        NSLog(@"Misson: 3, %@", [NSThread currentThread]);
    }
});

@protocol NSLocking
- (void)lock;
- (void)unlock;
@end

@interface NSLock : NSObject <NSLocking> {
- (BOOL)tryLock;
- (BOOL)lockBeforeDate:(NSDate *)limit;

@interface NSRecursiveLock : NSObject <NSLocking> {
- (BOOL)tryLock;
- (BOOL)lockBeforeDate:(NSDate *)limit;

@interface NSCondition : NSObject <NSLocking> {
- (void)wait;
- (BOOL)waitUntilDate:(NSDate *)limit;
- (void)signal;
- (void)broadcast;

@interface NSConditionLock : NSObject <NSLocking> {
- (instancetype)initWithCondition:(NSInteger)condition;
@property (readonly) NSInteger condition;
- (void)lockWhenCondition:(NSInteger)condition;
- (BOOL)tryLock;
- (BOOL)tryLockWhenCondition:(NSInteger)condition;
- (void)unlockWithCondition:(NSInteger)condition;
- (BOOL)lockBeforeDate:(NSDate *)limit;
- (BOOL)lockWhenCondition:(NSInteger)condition beforeDate:(NSDate *)limit;

- (void)otherTest1
{
    [[[NSThread alloc] initWithTarget:self selector:@selector(__three) object:nil] start];
    
    [[[NSThread alloc] initWithTarget:self selector:@selector(__two) object:nil] start];
    
    [[[NSThread alloc] initWithTarget:self selector:@selector(__one) object:nil] start];
}

- (void)__one
{
    [self.conditionLock lockWhenCondition:1];
    sleep(1);
    NSLog(@"%s", __func__);
    [self.conditionLock unlockWithCondition:2];
}

- (void)__two
{
    [self.conditionLock lockWhenCondition:2];
    sleep(1);
    NSLog(@"%s", __func__);
    [self.conditionLock unlockWithCondition:3];
}

- (void)__three
{
    [self.conditionLock lockWhenCondition:3];
    sleep(1);
    NSLog(@"%s", __func__);
    [self.conditionLock unlockWithCondition:4];
}

// 创建串行队列
dispatch_queue_t queue = dispatch_queue_create("theQueue", DISPATCH_QUEUE_SERIAL);
// 把要保证线程安全的任务丢到队列中去执行
dispatch_sync(queue, ^{
    // 任务
});

// 设置信号量的初始值，用来控制最大并发量，这里最大并发量是5
dispatch_semaphore_t semaphore = dispatch_semaphore_create(5);
// 设置为1, 保证没有只有一个线程可以访问
dispatch_semaphore_t singleSemaphore = dispatch_semaphore_create(1);
// 如果信号量的值<=0, 当前线程就会进入休眠等待(直到信号量的值>0)
// 如果信号量的值>0,就减1，然后往下执行后面的代码
dispatch_semaphore_wait(singleSemaphore, DISPATCH_TIME_FOREVER);
需要保证线程同步的代码 ...
// 让信号量的值加1
dispatch_semaphore_signal(singleSemaphore);

// 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;
}

typedef struct alignas(CacheLineSize) SyncData {
    struct SyncData* nextData;
    DisguisedPtr<objc_object> object;
    int32_t threadCount;  // number of THREADS using this block
    recursive_mutex_t mutex;
} SyncData;

using recursive_mutex_t = recursive_mutex_tt<LOCKDEBUG>;

template <bool Debug>
class recursive_mutex_tt : nocopy_t {
    os_unfair_recursive_lock mLock;

  public:
    constexpr recursive_mutex_tt() : mLock(OS_UNFAIR_RECURSIVE_LOCK_INIT) {
        lockdebug_remember_recursive_mutex(this);
    }

    constexpr recursive_mutex_tt(const fork_unsafe_lock_t unsafe)
        : mLock(OS_UNFAIR_RECURSIVE_LOCK_INIT)
    { }

    void lock()
    {
        lockdebug_recursive_mutex_lock(this);
        os_unfair_recursive_lock_lock(&mLock);
    }

    void unlock()
    {
        lockdebug_recursive_mutex_unlock(this);

        os_unfair_recursive_lock_unlock(&mLock);
    }

    void forceReset()
    {
        lockdebug_recursive_mutex_unlock(this);

        bzero(&mLock, sizeof(mLock));
        mLock = os_unfair_recursive_lock OS_UNFAIR_RECURSIVE_LOCK_INIT;
    }

    bool tryUnlock()
    {
        if (os_unfair_recursive_lock_tryunlock4objc(&mLock)) {
            lockdebug_recursive_mutex_unlock(this);
            return true;
        }
        return false;
    }

    void assertLocked() {
        lockdebug_recursive_mutex_assert_locked(this);
    }

    void assertUnlocked() {
        lockdebug_recursive_mutex_assert_unlocked(this);
    }
};

// 初始化队列
dispatch_queue_t queue = dispatch_queue_create("queue",DISPATCH_QUEUE_CONCURRENT);
// 读
dispatch_async(queue, ^{
    
});
// 写
dispatch_barrier_async(queue, ^{
    
});