// 获取主线程当前执行的串行队列
dispatch_queue_t dispatch_get_main_queue()

// 获取对应优先级的全局并发队列
dispatch_queue_t dispatch_get_global_queue(long identifier, unsigned long flags)

DISPATCH_QUEUE_PRIORITY_HIGH        // 高优先级
DISPATCH_QUEUE_PRIORITY_DEFAULT     // 默认优先级
DISPATCH_QUEUE_PRIORITY_LOW         // 低优先级
DISPATCH_QUEUE_PRIORITY_BACKGROUND  // 后台优先级

// 创建一个新的队列
dispatch_queue_t dispatch_queue_create(const char *_Nullable label, dispatch_queue_attr_t attr)

// example : 创建一个串行队列
dispatch_queue_t serialQueue = dispatch_queue_create("com.mesird.queue.calculation", DISPATCH_QUEUE_CONCURRENT);

[NetworkService querySomeDataWithParameters:parameters andHandlerResult:^(BOOL success, NSDictionary *result, NSError *error) {
    if (success) {
        dispatch_async(dispatch_get_main_queue(), ^{
            // do some UI render work on main queue
        });
    } else {
        NSLog(@"Response error : %@", error.localizedDescription);
    }
}];

- (void)viewDidLoad {
    [super viewDidLoad]; 
    
    dispatch_sync(dispatch_get_main_queue(), ^{
        // do some UI render work
    });
}

...
@property (nonatomic, strong) NSMutableArray *objects;

...
- (void)addObjectToArray:(id)object {
    if (object) {
        [self.objects addObject:object];
    }
}

- (NSArray *)readArray {
    return [NSArray arrayWithArray:self.objects];
}

// 添加栅栏任务并异步执行
void dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block);
// 添加栅栏任务并同步执行
void dispatch_barrier_sync(dispatch_queue_t queue, dispatch_block_t block);

...
@property (nonatomic, strong) NSMutableArray *objects;
@property (nonatomic, strong) dispatch_queue_t objectsAccessQueue;

...
- (instancetype)init {
    if (self = [super init]) {
        // some initial code here
        self.objectsAccessQueue = dispatch_queue_create("com.mesird.queue.barrier", DISPATCH_QUEUE_CONCURRENT);
    }
    return self;
}

- (void)addObjectToArray:(id)object {
    if (object) {
        dispatch_barrier_async(self.objectsAccessQueue, ^{
            [self.objects addObject:object];
        });
    }
}

- (NSArray *)readArray {
    __block NSArray *retObjects;
    dispatch_sync(self.objectsAccessQueue, ^{
        retObjects = [NSArray arrayWithArray:self.objects];
    });
    return retObjects;
}

+ (instancetype)sharedManager {
    static SomeManager *sharedManager = nil;
    if (!sharedManager) {
        sharedManager = [[SomeManager alloc] init];
        // do some instance initialization here
    }
    return sharedManager;
}

+ (instancetype)sharedManager {
    static SomeManager *sharedManager = nil;
    @synchronized(self) {
        if (!sharedManager) {
            sharedManager = [[SomeManager alloc] init];
            // do some instance initialization here
        }
    }
    return sharedManager;
}

+ (instancetype)sharedManager {
    static SomeManager *sharedManager = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        sharedManager = [[SomeManager alloc] init];
        // do some instance initialization here
    });
    return sharedManager;
}

void dispatch_after(dispatch_time_t when, dispatch_queue_t queue, dispatch_block_t block);

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    // 执行动画，渐隐 alertView
    [UIView animateWithDuration:0.3 animations:^{
        self.transparentAlertView.alpha = 0;
    } completion:^(BOOL finished) {
        if (finished) {
            [self.transparentAlertView removeFromSuperView];
        }
    }];
});

void dispatch_apply(size_t iterations, dispatch_queue_t queue, void (^block)(size_t));

NSArray *objects = @[@"1", @"a", @"text"];
dispatch_queue_t queue = dispatch_queue_create("com.mesird.queue.interation", DISPATCH_QUEUE_SERIAL);
dispatch_apply(objects.count, queue, ^(size_t index){
    NSLog(@"%@", objects[index]);
});
NSLog(@"Done");

dispatch_queue_t serialQueue = dispatch_queue_create("com.mesird.queue.serial", DISPATCH_QUEUE_SERIAL);
dispatch_async(serialQueue, ^{
    // handle some tasks here
});

// 队列任务全部结束后通知执行任务
void dispatch_group_notify(dispatch_group_t group, dispatch_queue_t queue, dispatch_block_t block);

dispatch_queue_t queryQueueA = dispatch_queue_create("com.mesird.queue.queryA", DISPATCH_QUEUE_CONCURRENT);
dispatch_queue_t queryQueueB = dispatch_queue_create("com.mesird.queue.queryB", DISPATCH_QUEUE_CONCURRENT);
dispatch_group_t queryGroup = dispatch_group_create();
dispatch_group_async(queryQueueA, ^{
    // request some data from server
});
dispatch_group_async(queryQueueB, ^{
    // request some data from server
});
__weak __typeof(self) weakSelf = self;
dispatch_group_notify(queryGroup, dispatch_get_main_queue(), ^{
    // refresh UI on main queue
    __strong __typeof(weakSelf) strongSelf = weakSelf;
    [strongSelf.tableView reloadData];
});

long dispatch_group_wait(dispatch_group_t group, dispatch_time_t timeout);

// 创建信号量
dispatch_semaphore_t dispatch_semaphore_create(long value);
// 资源等待并占用
long dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout);
// 资源释放
long dispatch_semaphore_signal(dispatch_semaphore_t dsema);

NSMutableArray *objects = [NSMutableArray array];
dispatch_queue_t queue = dispatch_queue_create("com.mesird.queue.concurrent", DISPATCH_QUEUE_CONCURRENT);
// 创建信号量，初始值为 1
dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
for (int i = 0; i < 100; i ++) {
   dispatch_async(queue, ^{
       // 等待并持有信号量 (-1)
       dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
       // 使用资源
       [objects addObject:@(i)];
       // 释放信号量 (+1)
       dispatch_semaphore_signal(semaphore);
   });
}