GCD实现多线程相关API简介

淡淡的烟草味﹌ 2022-03-06 01:26 222阅读 0赞

## 一、同步、异步 ##

学习多线程，首先需要了解同步（sync）、异步（async）。

同步：方法被提交后立即调用，完成后返回；

异步：方法被提交后立即返回，而不等待方法被调用。

**示例代码：**

同步：

int main(int argc, const char * argv[]) {
        @autoreleasepool {
            // insert code here...
            NSLog(@"Hello, World!");
            
            dispatch_queue_t concurrentQueue = dispatch_queue_create("test.sec.com", DISPATCH_QUEUE_CONCURRENT);
            dispatch_sync(concurrentQueue, ^{
                [NSThread sleepForTimeInterval:2];
                NSLog(@"task-1");
            });
            dispatch_sync(concurrentQueue, ^{
                [NSThread sleepForTimeInterval:1];
                NSLog(@"task-2");
            });
            
            sleep(5);
    }

结果：

![20190318150251351.png][]

异步：

int main(int argc, const char * argv[]) {
        @autoreleasepool {
            // insert code here...
            NSLog(@"Hello, World!");
            
            dispatch_queue_t concurrentQueue = dispatch_queue_create("test.sec.com", DISPATCH_QUEUE_CONCURRENT);
            dispatch_async(concurrentQueue, ^{
                [NSThread sleepForTimeInterval:2];
                NSLog(@"task-1");
            });
            dispatch_async(concurrentQueue, ^{
                [NSThread sleepForTimeInterval:1];
                NSLog(@"task-2");
            });
            
            sleep(5);
    }

结果：

![20190318150606580.png][]

## 二、队列  ##

串行队列：同一时刻只执行一个任务，并依次按加入队列的顺序执行，执行完一个任务再执行下一任务；

并行队列：同一时刻可执行多个任务，任务开始执行的顺序按加入顺序，但是执行完成的顺序是随机的；

主队列：全局的串行队列。

1.创建队列

dispatch_queue_create(const char *_Nullable label, dispatch_queue_attr_t _Nullable attr);

1.  队列标签；
2.  队列类型（并行队列：DISPATCH\_QUEUE\_CONCURRENT，串行队列：DISPATCH\_QUEUE\_SERIAL）。

2.获取全局并发队列

dispatch_get_global_queue(long identifier, unsigned long flags);

1.  队列服务质量（优先级）：
    
    QOS\_CLASS\_USER\_INTERACTIVE,
    
    QOS\_CLASS\_USER\_INITIATED,
    
    QOS\_CLASS\_DEFAULT,
    
    QOS\_CLASS\_UTILITY,
    
    QOS\_CLASS\_BACKGROUND,
    
    QOS\_CLASS\_UNSPECIFIED;
2.  始终为设置为 0。

3.获取主队列

dispatch_get_main_queue(void)

**示例代码：**

串行队列：

int main(int argc, const char * argv[]) {
        @autoreleasepool {
            // insert code here...
            NSLog(@"Hello, World!");
            
            dispatch_queue_t serialQueue = dispatch_queue_create("test.sec.com", DISPATCH_QUEUE_SERIAL);
            dispatch_async(serialQueue, ^{
                [NSThread sleepForTimeInterval:2];
                NSLog(@"task-1");
            });
            dispatch_async(serialQueue, ^{
                [NSThread sleepForTimeInterval:1];
                NSLog(@"task-2");
            });
            
            sleep(5);
    }

结果：

![20190318161242533.png][]

并行队列：

int main(int argc, const char * argv[]) {
        @autoreleasepool {
            // insert code here...
            NSLog(@"Hello, World!");
            
            dispatch_queue_t concurrentQueue = dispatch_queue_create("test.sec.com", DISPATCH_QUEUE_CONCURRENT);
            dispatch_async(concurrentQueue, ^{
                [NSThread sleepForTimeInterval:2];
                NSLog(@"task-1");
            });
            dispatch_async(concurrentQueue, ^{
                [NSThread sleepForTimeInterval:1];
                NSLog(@"task-2");
            });
            
            sleep(5);
    }

结果：

![20190318161533969.png][]

## 三、分组 ##

组可以跟踪多个代码块何时全部完成（即使它们运行在不同的队列上）。

1.      dispatch_group_t dispatch_group_create(void)
    
    创建分组；
2.      void dispatch_group_async(dispatch_group_t group, dispatch_queue_t queue, dispatch_block_t block);
    
    向队列提交代码块 ，并将队列与分组关联；
3.      void dispatch_group_notify(dispatch_group_t group, dispatch_queue_t queue, dispatch_block_t block);
    
     当分组中代码块全部执行完成后，向队列提交代码块；   
4.      long dispatch_group_wait(dispatch_group_t group, dispatch_time_t timeout);
    
    阻塞当前线程，先执行分组中代码块；
5.      void dispatch_group_enter(dispatch_group_t group);
    
     分组任务引用计数加 1；
6.      void dispatch_group_leave(dispatch_group_t group);
    
    分组任务引用计数减 1。

**示例代码：**

分组执行同步任务：

int main(int argc, const char * argv[]) {
        @autoreleasepool {
            // insert code here...
            NSLog(@"Hello, World!");
            
            dispatch_queue_t concurrentQueue = dispatch_queue_create("test.secc.com", DISPATCH_QUEUE_CONCURRENT);
            dispatch_group_t group = dispatch_group_create();
            dispatch_group_async(group, concurrentQueue, ^{
                [NSThread sleepForTimeInterval:2];
                NSLog(@"task-1");
            });
            dispatch_group_async(group, concurrentQueue, ^{
                [NSThread sleepForTimeInterval:3];
                NSLog(@"task-2");
            });
            dispatch_group_async(group, concurrentQueue, ^{
                [NSThread sleepForTimeInterval:1];
                NSLog(@"task-3");
            });
            
            dispatch_group_async(group, concurrentQueue, ^{
                [NSThread sleepForTimeInterval:4];
                NSLog(@"task-4");
            });
            dispatch_group_notify(group, concurrentQueue, ^{
                NSLog(@"completion");
            });
            dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
            NSLog(@"主线程执行");
            sleep(8);

结果：

![20190318174411850.png][]

分组嵌套异步任务：

int main(int argc, const char * argv[]) {
        @autoreleasepool {
            // insert code here...
            NSLog(@"Hello, World!");
            
            dispatch_queue_t concurrentQueue = dispatch_queue_create("test.secc.com", DISPATCH_QUEUE_CONCURRENT);
            dispatch_group_t group = dispatch_group_create();
            dispatch_group_async(group, concurrentQueue, ^{
                [NSThread sleepForTimeInterval:2];
                NSLog(@"task-1");
            });
            dispatch_group_async(group, concurrentQueue, ^{
                [NSThread sleepForTimeInterval:3];
                NSLog(@"task-2");
            });
            dispatch_group_async(group, concurrentQueue, ^{
                [NSThread sleepForTimeInterval:1];
                NSLog(@"task-3");
            });
            
            dispatch_group_enter(group);
            dispatch_async(concurrentQueue, ^{
                [NSThread sleepForTimeInterval:4];
                NSLog(@"task-4");
                dispatch_group_leave(group);
            });
    
            dispatch_group_notify(group, concurrentQueue, ^{
                NSLog(@"completion");
            });
            dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
            NSLog(@"主线程执行");
            sleep(8);

结果：

![20190318174813530.png][]

## 四、信号量 ##

**示例代码： **

1.      dispatch_semaphore_t dispatch_semaphore_create(long value);
    
    创建信号量；
2.      long dispatch_semaphore_signal(dispatch_semaphore_t dsema);
    
    信号量值加 1；
3.      long dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout);
    
    如果信号量值为 0，则函数阻塞当前线程等待timeout；  
    在等待期间如果信号量值加 1就继续向下执行，并将信号量值减 1；  
    在等待期间如果信号量值始终为 0，那么timeout时，线程自动向下执行；  
    返回值为 0，表示timeout之前，线程被成功唤醒；  
    返回值非 0，表示timeout发生。

**示例代码：**

int main(int argc, const char * argv[]) {
        @autoreleasepool {
            // insert code here...
            NSLog(@"Hello, World!");
            dispatch_queue_global_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
            
            dispatch_semaphore_t semaphore = dispatch_semaphore_create(2);
            dispatch_async(globalQueue, ^{
                dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
                NSLog(@"run task-1");
                [NSThread sleepForTimeInterval:1];
                NSLog(@"complete task-1");
                dispatch_semaphore_signal(semaphore);
            });
            
            dispatch_async(globalQueue, ^{
                dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
                NSLog(@"run task-2");
                [NSThread sleepForTimeInterval:1];
                NSLog(@"complete task-2");
                dispatch_semaphore_signal(semaphore);
            });
            
            dispatch_async(globalQueue, ^{
                dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
                NSLog(@"run task-3");
                [NSThread sleepForTimeInterval:1];
                NSLog(@"complete task-3");
                dispatch_semaphore_signal(semaphore);
            });
            sleep(3);
    }

结果：

![20190318201901363.png][]

## 五、栅栏 ##

栅栏为并发队列中创建同步点。

1.      void dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block);
    
    提交栅栏，并立即返回；
2.      void dispatch_barrier_sync(dispatch_queue_t queue, DISPATCH_NOESCAPE dispatch_block_t block);
    
    提交栅栏，直至代码块完成才返回。

**如有不准确之处，欢迎批评指正**！

[20190318150251351.png]: /images/20220303/8cd9c93c9c69470f94e55713521dc0be.png
[20190318150606580.png]: /images/20220303/208846dc53d4494db9928fa28eaa73e3.png
[20190318161242533.png]: /images/20220303/e45e6c4092564638b91d30582370d3da.png
[20190318161533969.png]: /images/20220303/d857b199111345d2a763a6445fa155fe.png
[20190318174411850.png]: /images/20220303/8b2e255f89ab4a54be9d8b7a51a37173.png
[20190318174813530.png]: /images/20220303/c6ccbbe2354645259a70f85f45411aab.png
[20190318201901363.png]: /images/20220303/2d3aab29805b4131aca284ea3fc70d12.png