多线程编程 - GCD

柔光的暖阳◎ 2022-07-24 12:11 110阅读 0赞

# 多线程编程 - GCD #

## 什么是GCD？ ##

GCD本身是苹果公司为多核的并行运算提出的解决方案。GCD在工作时会自动利用更多的处理器核心，以充分利用更强大的机器。GCD是Grand Central Dispatch的简称，它是基于C语言的。如果使用GCD，完全由系统管理线程，我们不需要编写线程代码。只需定义想要执行的任务,然后添加到适当的调度队列(dispatch queue)。GCD会负责创建线程和调度你的任务，系统直接提供线程管理

## GCD的优势 ##

1.  GCD是苹果公司为多核的并行运算提出的解决方案GCD会自动利用更多的CPU内核（比如双核、四核）GCD会自动管理线程的生命周期（创建线程、调度任务、销毁线程）程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码。
2.  通过 GCD，开发者不用再直接跟线程打交道了，只需要向队列中添加代码块即可，GCD 在后端管理着一个线程池。GCD 不仅决定着你的代码块将在哪个线程被执行，它还根据可用的系统资源对这些线程进行管理。这样可以将开发者从线程管理的工作中解放出来，通过集中的管理线程，来缓解大量线程被创建的问题。
3.  GCD 带来的另一个重要改变是，作为开发者可以将工作考虑为一个队列，而不是一堆线程，这种并行的抽象模型更容易掌握和使用。
4.  GCD 公开有 5 个不同的队列：运行在主线程中的 main queue，3 个不同优先级的后台队列，以及一个优先级更低的后台队列（用于 I/O）。  
    如图：  
    ![这里写图片描述][20160523111403936]

## 调度队列(dispath queue) ##

1.  GCD的一个重要概念是队列，它的核心理念：将长期运行的任务拆分成多个工作单元，并将这些单元添加到dispath queue中，系统会为我们管理这些dispath queue，为我们在多个线程上执行工作单元，我们不需要直接启动和管理后台线程。
2.  系统提供了许多预定义的dispath queue，包括可以保证始终在主线程上执行工作的dispath queue。也可以创建自己的dispath queue，而且可以创建任意多个。GCD的dispath queue严格遵循FIFO(先进先出)原则，添加到dispath queue的工作单元将始终按照加入dispath queue的顺序启动。
3.  dispatch queue按先进先出的顺序,串行或并发地执行任务  
    1> serial dispatch queue一次只能执行一个任务, 当前任务完成才开始出列并启动下一个任务  
    2> concurrent dispatch queue则尽可能多地启动任务并发执行

## 创建和管理dispatch queue ##

### 获得全局并发Dispatch Queue (concurrent dispatch queue) ###

1> 并发dispatch queue可以同时并行地执行多个任务,不过并发queue仍然按先进先出的顺序来启动任务。并发queue会在之前的任务完成之前就出列下一个任务并开始执行。并发queue同时执行的任务数量会根据应用和系统动态变化,各种因素包括:可用核数量、其它进程正在执行的工作数量、其它串行dispatch queue中优先任务的数量等.  
2> 系统给每个应用提供三个并发dispatch queue,整个应用内全局共享,三个queue的区别是优先级。你不需要显式地创建这些queue,使用dispatch\_get\_global\_queue函数来获取这三个queue:

dispatch_queue_t queue = dispatch_get_global_queue(0, 0);

第一个参数用于指定优先级，分别使用DISPATCH\_QUEUE\_PRIORITY\_HIGH和DISPATCH\_QUEUE\_PRIORITY\_LOW两个常量来获取高和低优先级的两个queue；第二个参数目前未使用到，默认0即可  
3> 虽然dispatch queue是引用计数的对象,但你不需要retain和release全局并发queue。因为这些queue对应用是全局的,retain和release调用会被忽略。你也不需要存储这三个queue的引用,每次都直接调用dispatch\_get\_global\_queue获得queue就行了。

### 2.创建串行Dispatch Queue (serial dispatch queue) ###

1> 应用的任务需要按特定顺序执行时,就需要使用串行Dispatch Queue,串行queue每次只能执行一个任务。你可以使用串行queue来替代锁,保护共享资源 或可变的数据结构。和锁不一样的是,串行queue确保任务按可预测的顺序执行。而且只要你异步地提交任务到串行queue,就永远不会产生死锁  
2> 你必须显式地创建和管理所有你使用的串行queue,应用可以创建任意数量的串行queue,但不要为了同时执行更多任务而创建更多的串行queue。如果你需要并发地执行大量任务,应该把任务提交到全局并发queue  
3> 利用dispatch\_queue\_create函数创建串行queue,两个参数分别是queue名和一组queue属性

dispatch_queue_t queue;  
    queue = dispatch_queue_create("cn.itcast.queue", NULL);

### 3.运行时获得公共Queue ###

GCD提供了函数让应用访问几个公共dispatch queue:  
1> 使用dispatch\_get\_current\_queue函数作为调试用途,或者测试当前queue的标识。在block对象中调用这个函数会返回block提交到的queue(这个时候queue应该正在执行中)。在block对象之外调用这个函数会返回应用的默认并发queue。  
2> 使用dispatch\_get\_main\_queue函数获得应用主线程关联的串行dispatch queue  
3> 使用dispatch\_get\_global\_queue来获得共享的并发queue

### 4.Dispatch Queue的内存管理 ###

1> Dispatch Queue和其它dispatch对象(还有dispatch source)都是引用计数的数据类型。当你创建一个串行dispatch queue时,初始引用计数为 1,你可以使用dispatch\_retain和dispatch\_release函数来增加和减少引用计数。当引用计数到达 0 时,系统会异步地销毁这个queue  
2> 对dispatch对象(如dispatch queue)retain和release 是很重要的,确保它们被使用时能够保留在内存中。和OC对象一样,通用的规则是如果使用一个传递过来的queue,你应该在使用前retain,使用完之后release  
3> 你不需要retain或release全局dispatch queue,包括全局并发dispatch queue和main dispatch queue  
4> 即使你实现的是自动垃圾收集的应用,也需要retain和release创建的dispatch queue和其它dispatch对象。GCD 不支持垃圾收集模型来回收内存

## 四、添加任务到queue ##

要执行一个任务,你需要将它添加到一个适当的dispatch queue,你可以单个或按组来添加，也可以同步或异步地执行一个任务,也。一旦进入到queue,queue会负责尽快地执行你的任务。一般可以用一个block来封装任务内容。

### 1.添加单个任务到queue ###

1> 异步添加任务  
你可以异步或同步地添加一个任务到Queue,尽可能地使用dispatch\_async或dispatch\_async\_f函数异步地调度任务。因为添加任务到Queue中时,无法确定这些代码什么时候能够执行。因此异步地添加block或函数,可以让你立即调度这些代码的执行,然后调用线程可以继续去做其它事情。特别是应用主线程一定要异步地 dispatch 任务,这样才能及时地响应用户事件  
2> 同步添加任务  
少数时候你可能希望同步地调度任务,以避免竞争条件或其它同步错误。 使用dispatch\_sync和dispatch\_sync\_f函数同步地添加任务到Queue,这两个函数会阻塞当前调用线程,直到相应任务完成执行。注意：绝对不要在任务中调用 dispatch\_sync或dispatch\_sync\_f函数,并同步调度新任务到当前正在执行的 queue。对于串行queue这一点特别重要,因为这样做肯定会导致死锁;而并发queue也应该避免这样做。

// 调用前，查看下当前线程 
    NSLog(@"当前调用线程：%@", [NSThread currentThread]);  
    
    // 创建一个串行queue 
    dispatch_queue_t queue = dispatch_queue_create("cn.itcast.queue", NULL);  
    
    dispatch_async(queue, ^{  
        NSLog(@"开启了一个异步任务，当前线程：%@", [NSThread currentThread]);  
    });  
    
    dispatch_sync(queue, ^{  
        NSLog(@"开启了一个同步任务，当前线程：%@", [NSThread currentThread]);  
    });  
    // 销毁队列 
    dispatch_release(queue);

### 2.并发地执行循环迭代 ###

如果你使用循环执行固定次数的迭代, 并发dispatch queue可能会提高性能。  
例如下面的for循环：

int i;  
    int count = 10;  
    for (i = 0; i < count; i++) {  
       printf("%d ",i);  
    }

1> 如果每次迭代执行的任务与其它迭代独立无关,而且循环迭代执行顺序也无关紧要的话,你可以调用dispatch\_apply或dispatch\_apply\_f函数来替换循环。这两个函数为每次循环迭代将指定的block或函数提交到queue。当dispatch到并发 queue时,就有可能同时执行多个循环迭代。用dispatch\_apply或dispatch\_apply\_f时你可以指定串行或并发 queue。并发queue允许同时执行多个循环迭代,而串行queue就没太大必要使用了。  
下面代码使用dispatch\_apply替换了for循环,你传递的block必须包含一个size\_t类型的参数,用来标识当前循环迭代。第一次迭代这个参数值为0,最后一次值为count - 1

// 获得全局并发queue 
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);  
    size_t count = 10;
    dispatch_apply(count, queue, ^(size_t i) {  
        printf("%zd ", i);  
    });  
    // 销毁队列 
    dispatch_release(queue);

可以看出，这些迭代是并发执行的  
和普通for循环一样,dispatch\_apply和dispatch\_apply\_f函数也是在所有迭代完成之后才会返回，因此这两个函数会阻塞当前线程，主线程中调用这两个函数必须小心,可能会阻止事件处理循环并无法响应用户事件。所以如果循环代码需要一定的时间执行,可以考虑在另一个线程中调用这两个函数。如果你传递的参数是串行queue,而且正是执行当前代码的queue,就会产生死锁。

### 3.在主线程中执行任务 ###

1> GCD提供一个特殊的dispatch queue,可以在应用的主线程中执行任务。只要应用主线程设置了run loop(由CFRunLoopRef类型或NSRunLoop对象管理),就会自动创建这个queue,并且最后会自动销毁。非Cocoa应用如果不显式地设置run loop, 就必须显式地调用dispatch\_main函数来显式地激活这个dispatch queue，否则虽然你可以添加任务到queue,但任务永远不会被执行。  
2> 调用dispatch\_get\_main\_queue函数获得应用主线程的dispatch queue,添加到这个queue的任务由主线程串行化执行  
3> 代码实现，比如异步下载图片后，回到主线程显示图片

// 异步下载图片 
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{  
        NSURL *url = [NSURL URLWithString:@"http://car0.autoimg.cn/upload/spec/9579/u_20120110174805627264.jpg"];  
        UIImage *image = [UIImage imageWithData:[NSData dataWithContentsOfURL:url]];  
    
        // 回到主线程显示图片 
        dispatch_async(dispatch_get_main_queue(), ^{  
            self.imageView.image = image;  
        });  
    });

### 4.任务中使用Objective-C对象 ###

GCD支持Cocoa内存管理机制,因此可以在提交到queue的block中自由地使用Objective-C对象。每个dispatch queue维护自己的autorelease pool确保释放autorelease对象,但是queue不保证这些对象实际释放的时间。如果应用消耗大量内存,并且创建大量autorelease对象,你需要创建自己的autorelease pool,用来及时地释放不再使用的对象。

## 暂停和继续queue ##

我们可以使用dispatch\_suspend函数暂停一个queue以阻止它执行block对象;使用dispatch\_resume函数继续dispatch queue。调用dispatch\_suspend会增加queue的引用计数,调用dispatch\_resume则减少queue的引用计数。当引用计数大于0时,queue就保持挂起状态。因此你必须对应地调用suspend和resume函数。挂起和继续是异步的,而且只在执行block之间（比如在执行一个新的block之前或之后）生效。挂起一个queue不会导致正在执行的block停止。

## Dispatch Group的使用 ##

假设有这样一个需求：从网络上下载两张不同的图片，然后显示到不同的UIImageView上去，一般可以这样实现

// 根据url获取UIImage 
    - (UIImage *)imageWithURLString:(NSString *)urlString {  
        NSURL *url = [NSURL URLWithString:urlString];  
        NSData *data = [NSData dataWithContentsOfURL:url];  
        return [UIImage imageWithData:data];  
    }  
    
    - (void)downloadImages {  
        // 异步下载图片 
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{  
            // 下载第一张图片 
            NSString *url1 = @"http://car0.autoimg.cn/upload/spec/9579/u_20120110174805627264.jpg";  
            UIImage *image1 = [self imageWithURLString:url1];  
    
            // 下载第二张图片 
            NSString *url2 = @"http://hiphotos.baidu.com/lvpics/pic/item/3a86813d1fa41768bba16746.jpg";  
            UIImage *image2 = [self imageWithURLString:url2];  
    
            // 回到主线程显示图片 
            dispatch_async(dispatch_get_main_queue(), ^{  
                self.imageView1.image = image1;  
    
                self.imageView2.image = image2;  
            });  
        });  
    }

虽然这种方案可以解决问题，但其实两张图片的下载过程并不需要按顺序执行，并发执行它们可以提高执行速度。有个注意点就是必须等两张图片都下载完毕后才能回到主线程显示图片。Dispatch Group能够在这种情况下帮我们提升性能。下面先看看Dispatch Group的用处：  
我们可以使用dispatch\_group\_async函数将多个任务关联到一个Dispatch Group和相应的queue中，group会并发地同时执行这些任务。而且Dispatch Group可以用来阻塞一个线程, 直到group关联的所有的任务完成执行。有时候你必须等待任务完成的结果,然后才能继续后面的处理。  
下面用Dispatch Group优化上面的代码：

// 根据url获取UIImage 
    - (UIImage *)imageWithURLString:(NSString *)urlString {  
        NSURL *url = [NSURL URLWithString:urlString];  
        NSData *data = [NSData dataWithContentsOfURL:url];  
        // 这里并没有自动释放UIImage对象 
        return [[UIImage alloc] initWithData:data];  
    }  
    
    - (void)downloadImages {  
        dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);  
    
        // 异步下载图片 
        dispatch_async(queue, ^{  
            // 创建一个组 
            dispatch_group_t group = dispatch_group_create();  
    
            __block UIImage *image1 = nil;  
            __block UIImage *image2 = nil;  
    
            // 关联一个任务到group 
            dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{  
                // 下载第一张图片 
                NSString *url1 = @"http://car0.autoimg.cn/upload/spec/9579/u_20120110174805627264.jpg";  
                image1 = [self imageWithURLString:url1];  
            });  
    
            // 关联一个任务到group 
            dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{  
                // 下载第一张图片 
                NSString *url2 = @"http://hiphotos.baidu.com/lvpics/pic/item/3a86813d1fa41768bba16746.jpg";  
                image2 = [self imageWithURLString:url2];  
            });  
    
            // 等待组中的任务执行完毕,回到主线程执行block回调 
            dispatch_group_notify(group, dispatch_get_main_queue(), ^{  
                self.imageView1.image = image1;  
                self.imageView2.image = image2;  
    
                // 千万不要在异步线程中自动释放UIImage，因为当异步线程结束，异步线程的自动释放池也会被销毁，那么UIImage也会被销毁 
    
                // 在这里释放图片资源 
                [image1 release];  
                [image2 release];  
            });  
    
            // 释放group 
            dispatch_release(group);  
        });  
    }

dispatch\_group\_notify函数用来指定一个额外的block，该block将在group中所有任务完成后执行

## GCD的其他方法 ##

### GCD应用 单例模式 ###

在整个应用程序中只有一个实例，易于外界访问

static dispatch_once_t onceToken;
        dispatch_once(&onceToken, ^{
    
            NSLog(@"执行一次%@",[NSThread currentThread]);
    
        });

### 延迟操作 ###

// [self performSelector:@selector(handleAction) withObject:nil afterDelay:0];
    
        //2、
    
        //DISPATCH_TIME_NOW 从现在开始
        //delayInSeconds 延迟几秒
    
        dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC));
    
        // when dispatch_time_t
    
        dispatch_after(time, dispatch_get_main_queue(), ^{
    
            NSLog(@"%@",[NSThread currentThread]);
    
        });

### 调度组 ###

第一种方法：

//创建调度组
        dispatch_group_t group = dispatch_group_create();
        //获取全局队列
        dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
        //调度组的异步请求
        dispatch_group_async(group, queue, ^{
    
            [NSThread sleepForTimeInterval:2];
            NSLog(@"下载第一张图");
        });
        dispatch_group_async(group, queue, ^{
            [NSThread sleepForTimeInterval:3];
    
            NSLog(@"下载第二张图");
        });
        dispatch_group_async(group, queue, ^{
            [NSThread sleepForTimeInterval:1];
    
            NSLog(@"下载第三张图");
        });
        dispatch_group_async(group, queue, ^{
            [NSThread sleepForTimeInterval:5];
    
            NSLog(@"下载第四张图");
        });
        //notify通知，当所有异步请求完成时调用dispatch_group_notify
        dispatch_group_notify(group, queue, ^{
            NSLog(@"更新UI");
        });

第二种方法：

//创建调度组
        dispatch_group_t group = dispatch_group_create();
        //获取全局队列
        dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    
        //进入队列
        dispatch_group_enter(group);
        dispatch_async(queue, ^{
    
            [NSThread sleepForTimeInterval:2];
            NSLog(@"下载第一张图");
    
            //离开队列
            dispatch_group_leave(group);
        });
    
        dispatch_group_enter(group);
        dispatch_async(queue, ^{
    
            [NSThread sleepForTimeInterval:1];
            NSLog(@"下载第er张图");
    
            dispatch_group_leave(group);
        });
    
        dispatch_group_enter(group);
        dispatch_async(queue, ^{
    
            [NSThread sleepForTimeInterval:3];
            NSLog(@"下载第san张图");
    
            dispatch_group_leave(group);
        });
    
        //等待调度队列wait相当于一个阻塞状态
        dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
    
        NSLog(@"更新UI");

### 中断操作 ###

*  dispatch\_barrier\_async一定是自定义队，
 *  这里指定的并发队列应该是自己通过dispatch\_queue\_create函数创建的。如果你传的是一个串行队列或者全局并发队列，这个函数等同于dispatch\_async函数。

dispatch_queue_t queue = dispatch_queue_create("com.bjsxt", DISPATCH_QUEUE_CONCURRENT); //dispatch_get_global_queue(0, 0);
    
        dispatch_async(queue, ^{
            [NSThread sleepForTimeInterval:1];
            NSLog(@"1");
        });
    
        dispatch_async(queue, ^{
            [NSThread sleepForTimeInterval:3];
    
            NSLog(@"2");
        });
        dispatch_async(queue, ^{
    
            [NSThread sleepForTimeInterval:2];
    
            NSLog(@"3");
        });
    
        //中断操作dispatch_barrier_async
        dispatch_barrier_async(queue, ^{
            NSLog(@"--------");
            [NSThread sleepForTimeInterval:1];
    
        });
    
        dispatch_async(queue, ^{
    
            [NSThread sleepForTimeInterval:1];
            NSLog(@"4");
        });
        dispatch_async(queue, ^{
            NSLog(@"5");
        });

### 遍历操作 ###

dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
        //iterations 遍历的次数
        dispatch_apply(5, queue, ^(size_t i) {
            NSLog(@"%@",@(i));
        });

## 附录： ##

串行队列：一个一个的执行  
并行队列：可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）并发功能只有在异步（dispatch\_async）函数下才有效。

同步任务：不会开辟新的线程,任务在当前的线程中执行，同时任务是立刻执行  
异步任务：会开辟新的线程（主队列不可以）,任务在新开辟的线程执行（主队列在主线程中执行）,不是立刻 执行任务

同步任务串行队列：不会开启新的线程，当前的线程中顺序执行任务  
同步任务并行队列：不会开启新的线程，当前的线程中执行任务,立刻执行任务  
异步任务串行队列：会开辟一个新的线程，在新开辟的线程中执行 任务,不是立刻执行  
异步任务并行队列：会开辟新的线程,在新开辟的线程中执行任务,任务的完成顺序是无序的，不是立刻执行

主队列（特殊的串行队列）：任务只会在主线程中调度，不会开辟新的线程（一般用于刷新UI）  
异步任务主队列：不会开辟新的线程,当前的线程中执行任务,不会立刻执行任务  
同步任务主队列：死锁

全局队列（并行队列）：全局队列供给应用程序共享,可以设置优先级

开辟新的线程：由任务决定,同步任务不会开辟新的线程,异步任务会开辟新的线程（主队列不会开辟新的线程）  
开辟多少线程：由队列决定，串行队列只会开启一个线程，并行队列会开辟多个线程，具体多少个由任务的数量和GCD的底层来决定的

[20160523111403936]: /images/20220722/bf989975cda145f9ab0aa012db9ab570.png