iOS 多线程-GCD

Posted CoderStar

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了iOS 多线程-GCD相关的知识，希望对你有一定的参考价值。

Hi Coder，我是 CoderStar！

今天给大家带来多线程系列的第二篇文章 -- GCD，其大概率是我们在使用多线程时最常用的方式了。

GCD 全称是 Grand Central Dispatch，翻译过来就是大规模中央调度。根据官方文档，它的作用是：通过向系统管理的调度队列中提交任务，在多核硬件上同时执行代码。它提供了一套机制，让你可以充分利用硬件的多核性能，并且让你不用再调用那些繁琐的底层线程 API，编写易于理解和修改的代码。

对开发者而言，面对的不再是上一篇文章ios 多线程-Thread所描述的线程，CGD 将线程概念模糊掉，开发者转而面对的是更上层的队列和任务，不再需要考虑线程的周期以及调度等等，这些交由 GCD 内部处理就好。

本文对一些概念性的东西可能会一笔带过，主要介绍日常开发的一些经验。同时更多细节大家可以看苹果开源出来关于 GCD 的源码--

一般情况下我们可以将队列分为串行和并行两种，其中主队列是一种特殊的串行队列，全局队列是一组特殊的并行队列。

方法。

autoreleaseFrequency

这个属性表示 autorelease pool 的自动释放频率， autorelease pool 管理着任务对象的内存周期。包含三个属性：

  • inherit：继承目标队列的该属性
  • workItem：跟随每个任务的执行周期进行自动创建和释放
  • never：不会自动创建 autorelease pool，需要手动管理。

    • 一般任务采用 .workItem 属性就够了，特殊任务如在任务内部大量重复创建对象的操作可选择 .never 属性手动创建 autorelease pool。

    target

    这个属性设置的是队列的目标队列，即实际上会将该队列的任务放到指定队列中运行。其实在程序中手动创建的队列，最终都会指向系统自带的主队列或者全局队列。 默认情况下，指向的是优先级为default的全局队列。

    需要特别注意的是，在 Swift 3 及之后，对目标队列的设置进行了约束，只有两种情况可以显式地设置目标队列，具体原因可看设定为initiallyInactive，然后在队列执行，activate() 之前可以指定目标队列。

    其实利用这个属性，我们可以完成一些所谓的骚操作，比如将多个并行队列的异步任务手动变成同步执行。

    GCD层次图

    qos 属性扩展

    如果大家对上次的iOS 多线程-Thread还有印象的话，想必会对Thread的qualityOfService属性有点印象，其类型为QualityOfService；iOS 多线程另外一个比较关键的结构Operation也有一个一样的属性。

    至于 GCD，其类似属性便为DispatchQoS类型，其为一个 struct类型，不止队列有这个属性，任务也有这个属性，换句话说，其实这个属性主要是作用在任务上的，源码解析可见下文的DispatchWorkItem节。如果不想阅读源码，我们通过官方文档看下其定义描述也清楚，The quality of service, or the execution priority, to apply to tasks.，一个tasks概括了一切。

    但是需要注意的是 global 队列创建的时候其 qos 参数类型为DispatchQoS.QoSClass，为DispatchQoS结构体下的一个enum类型，那两者的区别是什么呢？

    个人猜测是这样的，不一定正确，有比较清楚的同学还望不吝赐教。

    DispatchQoS.QoSClass文档定义描述为Quality-of-service classes that specify the priorities for executing tasks.，表明为执行任务的优先级，这里是指真正调度任务管理者自身的优先级，也就是全局并行队列，我们也可以看到这个属性目前只应用在global队列上。DispatchQoS.QoSClass描述的是最终调度队列 -- 全局并行队列的优先级（对应到底层线程池也可能是具体线程的优先级），那DispatchQoS描述的是任务项的优先级。

    该类属性其实都表示服务质量等级，相关具体细节可查看

    同步、异步是对任务的描述，不是对线程的描述。在 GCD 中，对开发者而言，任务才是关注的操作单位，上述的队列只是对任务进行管理和调度。

    我们一般往队列中加入任务是直接使用闭包，其实我们还有另外的选择，就是 DispatchWorkItem，即任务对象。比如上述的栅栏函数就有任务对象的写法。
    任务组的主要应用场景：当需要一组任务结束后再统一去执行一些操作；如等到几个没有顺序要求的网络请求成功之后再去统一刷新 UI。
    任务组（DispatchGroup）主要职责：当队列中所有任务都执行完毕之后，会发出一个通知表示任务执行完毕。其中任务组判断任务执行完毕的时机是入组任务数等于出组任务数。并且需要注意的是，任务组的单位是任务，与队列无关，换句话来说就是任务组是可以跨队列的。任务组与队列需要关联来实现上述操作，关联方式包括两种：自动关联及手动关联；
    和 group.leave() 需要成对存在。
  • 当组内没有任务时，group.notify会直接执行；
  • 当任务组的入组数大于出组数，group.notify永远不会执行；
  • 当出组数大于入组数，程序会 Crash。
    • group.notify 是异步执行的，如果想要阻塞当前线程，使任务组的任务执行完毕，可以使用 group.wait()。
    可能细心的同学会将任务组和栅栏函数进行比较，因为两者之间有一点是相似的，就是等待若干个任务全部执行完毕之后再执行后续操作，确实是这样，在一定场景下，两者是可以互换的，但是也得清楚两者之间的区别。
  • 栅栏函数针对的是同一个队列中的任务，而任务组执行单位为任务，可以跨队列；
  • 栅栏函数中无法灵活的控制任务完成的时机，如果是普通的任务还好，如果是网络请求这种类似\'双任务制\'的任务，便不适用了。因为当网络请求成功发出后，队列便会认为任务执行成功，但是实际上网络请求还未成功回调，即任务还未完成。
    • 双任务制可能表述不是很准确，这里就简单理解为网络请求发送为一个任务，网络请求接收为一个任务。
    上述任务组能保证几个网络请求全部完成之后再进行统一的操作，但是无法控制网络请求执行的顺序，如果需要控制网络请求执行的顺序（比如第二个网络请求的参数需要根据第一个网络请求返回值进行控制），我们就需要用到信号量（Semaphore）了。
    控制网络请求的执行顺序这种场景其实比较常见，也是面试比较常见的场景题，那除了信号量的解决方式之外，还可以利用 Operation 的任务依赖（不是简单的使用BlockOperation或者InvocationOperation）。
    其实信号量本质是控制最大并发数，但是可以利用其特性可以实现类似互斥锁的功能，如：
    GCD 中还有一些知识点没有讲到，如DispatchSource、DispatchIO、DispatchData，以及在定时器中的应用等等，后面可能还会再写一个续篇。
    新的一周要更加努力呀！
    Let\'s be CoderStar!
    参考资料
  • DispatchQueueTest[6]
    • 参考资料
    [1]
    swift-corelibs-libdispatch: https://github.com/apple/swift-corelibs-libdispatch
    [2]
    DispatchQueue setTarget 问题: https://bugs.swift.org/browse/SR-1859
    [3]
    Prioritize Work with Quality of Service Classes: https://developer.apple.com/library/archive/documentation/Performance/Conceptual/EnergyGuide-iOS/PrioritizeWorkWithQoS.html#//apple_ref/doc/uid/TP40015243-CH39-SW1
    [4]
    Kingfisher: https://github.com/onevcat/Kingfisher/blob/master/Sources/Utility/CallbackQueue.swift
    [5]
    Queue.swift: https://github.com/apple/swift-corelibs-libdispatch/blob/main/src/swift/Queue.swift
    [6]
    DispatchQueueTest: https://github.com/pmtao/DispatchQueueTest
    有一个技术的圈子与一群志同道合的朋友非常重要，来我的技术公众号，这里只聊技术干货。
    微信公众号：CoderStar

    iOS-多线程之GCD(原创)
    

    前言
    

    GCD
    

    全称 Grand Central DisPath NSOperation便是基于GCD的封装
    

     
    

    基础知识
    

    1.GCD的优势
    

     (1)为多核的并行运算提出了解决方案
    

     (2)GCD会自动利用更多的CPU内核 比和双核 四核
    

     (3).GCD自动管理线程的生命周期(创建线程 调度任务 销毁线程)
    

     (4).程序员只需告诉GCD想要执行什么任务 不需要编写任何线程管理代码
    

     
    

     2.GCD中有2个核心概念
    

     任务： 执行什么操作
    

     队列： 用来存放任务
    

     
    

     3.队列可以分为两大类型
    

     串行队列(Serial Dispatch Queue)：只有一个线程，加入到队列中的操作按添加顺序依次执行，一个任务执行完毕后，才能再执行下一个任务。
    

     并发队列(Concurrent Dispatch Queue)：有多个线程，操作进来以后他会将这些线程安排在可用的处理器上，同时保证先进来的任务优先处理。
    

     其实在GCD中还有一个特殊队列就是主队列 主队列中永远只有一个线程-主线程 用来执行主线程的操作任务
    

     
    

     4.采用GCD做多线程 可以抽象分为二步
    

     (1)找到队列(主队列或串行队列或并行队列)
    

     (2)在队列中用同步或者异步的方式执行任务
    

     
    

     5.执行队列中的任务的二种方式
    

     (1)同步 只能在当前线程执行任务 不具备开启新线程的能力--主线程
    

     (2)异步 可以在新的线程中执行任务 具备开启新线程的能力--子线程
    

     
    

    下面介绍一下串行 并行 同步 异步 
    

    - (void)viewDidLoad {
    

        [super viewDidLoad];
    

        self.view.backgroundColor = [UIColor whiteColor];
    

        // Do any additional setup after loading the view, typically from a nib.
    

    #pragma mark ====串行同步====
    

        
    

    //    //1.找到队列 第一个参数:该队列的名字 第二个参数:指定队列的类型
    

    //    dispatch_queue_t serialQueue = dispatch_queue_create("serialQueue",DISPATCH_QUEUE_SERIAL);
    

    //    //2.给队列指定任务 第一个参数:任务在哪个队列中执行 第二个参数:想要执行的操作
    

    //    //asyn是异步 syn是同步
    

    //    dispatch_sync(serialQueue, ^{
    

    //        NSLog(@"1===%@",[NSThread currentThread]);
    

    //    });
    

    //    
    

    #pragma mark ====串行异步====
    

    //    dispatch_queue_t serialQueue = dispatch_queue_create("serialQueue",DISPATCH_QUEUE_SERIAL);
    

    //    dispatch_async(serialQueue, ^{
    

    //        NSLog(@"1===%@",[NSThread currentThread]);
    

    //    });
    

    #pragma mark ====并行同步====
    

    //    dispatch_queue_t concurrentQueue = dispatch_queue_create("concurrentQueue",DISPATCH_QUEUE_CONCURRENT);
    

    //    dispatch_sync(concurrentQueue, ^{
    

    //        NSLog(@"1===%@",[NSThread currentThread]);
    

    //    });
    

    #pragma mark ====并行异步====
    

            dispatch_queue_t concurrentQueue = dispatch_queue_create("concurrentQueue",DISPATCH_QUEUE_CONCURRENT);
    

            dispatch_async(concurrentQueue, ^{
    

                NSLog(@"1===%@",[NSThread currentThread]);
    

            });
    

    }
    

    此时我们新建一个类来看一下 用GCD的形式来加载网络图片让它显示在self.view上 我这里为它命名为OneImageViewController  效果图以及.m代码如下
    

    技术分享
    

    

    #import "OneImageViewController.h"
#define kurl @"http://store.storeimages.cdn-apple.com/8748/as-images.apple.com/is/image/AppleInc/aos/published/images/s/38/s38ga/rdgd/s38ga-rdgd-sel-201601?wid=848&hei=848&fmt=jpeg&qlt=80&op_sharpen=0&resMode=bicub&op_usm=0.5,0.5,0,0&iccEmbed=0&layer=comp&.v=1454777389943"
@interface OneImageViewController ()
{
    UIImageView *imageView;
}
@end

@implementation OneImageViewController
- (void)viewDidLoad {
    [super viewDidLoad];
    self.view.backgroundColor = [UIColor whiteColor];
    /*
     1.创建视图
     2.创建一个串行队列
     3.用异步方式执行队列中的任务
     4.加载网络资源
     5.回到主线程 更新UI
     
     
     */
    //1.创建视图
    imageView = [[UIImageView alloc]initWithFrame:CGRectMake(50, 50, 200, 200)];
    [self.view addSubview:imageView];
    //2.创建一个串行队列
    dispatch_queue_t serialQueue = dispatch_queue_create("serialQueue", DISPATCH_QUEUE_SERIAL);
    //3.用异步方式执行队列中的任务
    dispatch_async(serialQueue, ^{
        //4.加载网络资源
        NSData *data = [NSData dataWithContentsOfURL:[NSURL URLWithString:kurl]];
        UIImage *image = [UIImage imageWithData:data];
        //5.回到主线程 dispatch_get_main_queue这个函数 找到主队列
        dispatch_queue_t mainQueue = dispatch_get_main_queue();
        dispatch_sync(mainQueue, ^{
           //6.更新UI
            imageView.image = image;
        });
        
    });


}
@end

    

    

    　　
    

    利用GCD加载多张网络图片 我在这里给类命名为MoreImageViewViewController 效果图以及.m代码如下
    

    技术分享
    

     
    

    

    #import "MoreImageViewViewController.h"
#define kurl @"http://store.storeimages.cdn-apple.com/8748/as-images.apple.com/is/image/AppleInc/aos/published/images/s/38/s38ga/rdgd/s38ga-rdgd-sel-201601?wid=848&hei=848&fmt=jpeg&qlt=80&op_sharpen=0&resMode=bicub&op_usm=0.5,0.5,0,0&iccEmbed=0&layer=comp&.v=1454777389943"
@interface MoreImageViewViewController ()
{
    int imageIndex;
    dispatch_queue_t concurrentQueue;
    
}
@end

@implementation MoreImageViewViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    self.view.backgroundColor = [UIColor whiteColor];
    self.edgesForExtendedLayout = UIRectEdgeNone;
    /*
     1.创建多个视图
     2.找到并行队列
     3.给这个并行队列指定多个任务
     4.在子线程加载网络资源
     5.回到主线程
     6.更新UI
     */
    
    imageIndex = 100;
    
    //1.创建多个视图
    for (int row = 0; row<3; row++) {
        for (int list = 0; list<2; list++) {
            
            UIImageView *imageView = [[UIImageView alloc]initWithFrame:CGRectMake(10+list*200, 10+row*200, 180, 180)];
            
            //imageView.backgroundColor = [UIColor orangeColor];
            
             imageView.tag = imageIndex++;
            
            [self.view addSubview:imageView];
            
        }
    }
    //2.找到并行队列 dispatch_get_global_queue 获取到系统的全局并列队列
    
    //第一个参数:是优先级 第二个参数:保留参数 没用
//    dispatch_queue_t concurrentQueue = dispatch_get_global_queue(0, 0);
    
      concurrentQueue = dispatch_queue_create("concurrentQueue", DISPATCH_QUEUE_SERIAL);
    
    //3.给这个并行队列指定多个任务
    for (int index = 0; index<6; index++) {
        dispatch_async(concurrentQueue, ^{
            [NSThread sleepForTimeInterval:0.5];
            //4.加载网络资源
            NSData *data = [NSData dataWithContentsOfURL:[NSURL URLWithString:kurl]];
            UIImage *image = [UIImage imageWithData:data];
            //5.回到主线程
            dispatch_sync(dispatch_get_main_queue(), ^{
                //6.更新UI
                UIImageView *imageView = [self.view viewWithTag:100+index];
                imageView.image = image;
            });

        });
    }
    
    [self controlBtn];
}

- (void)controlBtn{
    
    
    UISegmentedControl *segment = [[UISegmentedControl alloc]initWithItems:@[@"暂停",@"开启",]];
    
    segment.frame = CGRectMake(50, 620, 300, 50);
    
    segment.apportionsSegmentWidthsByContent = YES;
    
    [self.view addSubview:segment];
    
    [segment addTarget:self action:@selector(clickSegment:) forControlEvents:UIControlEventValueChanged];
}

- (void)clickSegment:(UISegmentedControl *)sender {
    
    switch (sender.selectedSegmentIndex) {
            
        case 0:{
            //暂停队列
            dispatch_suspend(concurrentQueue);
        }break;
            
        case 1:{
            //恢复队列
            dispatch_resume(concurrentQueue);
            
        }break;
            
    }
    

    

     
    

    开发中我们可能会用到线程锁 比如购票抢票这一功能  
    

    没线程锁的情况下：  我走进购票大厅，买票的人都没有排队，我好不容易挤到窗口前，正打算掏钱买票的时候，旁边有人已经把钱给了售票员。虽然你的线程已经开始执行买票的方法，但当你去拿票时，也就是将票数减一时，CPU将你的线程给中断，开始执行其他的线程，CPU返回继续执行你的线程的时候，票已经没了。
    

    有线程锁的情况下：* 我走进购票大厅，买票的人都在排队，当我到柜台能保证我买票的关键过程，也就是报站、掏钱、拿票过程不受干扰，我采用线程锁将这个关键过程给锁起来，以保证我能顺利的买到票。
    

    我在这里命名为GCDLockViewController 具体.m代码如下
    

    

    #import "GCDLockViewController.h"

@interface GCDLockViewController ()
{
    NSLock *mylock;
}
@end

@implementation GCDLockViewController
- (void)viewDidLoad {
    
    [super viewDidLoad];
    
    self.view.backgroundColor = [UIColor whiteColor];
    //实例化一个线程锁
    mylock = [NSLock new];
#pragma mark ====线程锁====
    __block int ticketNum = 10;
    dispatch_queue_t concurrent = dispatch_get_global_queue(0, 0);
    for (int index = 0; index<15; index++) {
        dispatch_async(concurrent, ^{
            
//            [mylock lock];
//            if (ticketNum>0) {
//                ticketNum--;
//                NSLog(@"还剩%d张票",ticketNum);
//            }
//            [mylock unlock];
            //参数一般是self 与self相关的变量 多个线程同时同时只访问一次
            @synchronized(self) {
                if (ticketNum>0) {
                                    ticketNum--;
                                    NSLog(@"还剩%d张票",ticketNum);
                                }

            }
            
            
            
        });
    }
    

}
@end

    

    

    　
    

     
    

     
    

     
    以上是关于iOS 多线程-GCD的主要内容，如果未能解决你的问题，请参考以下文章
     

     iOS底层探索之多线程—GCD源码分析( 信号量dispatch_semaphore_t)
    

     iOS多线程开发之GCD（下篇）
    

     第80题JAVA高级技术-多线程14（闭锁和栅栏)
    

     iOS-多线程：『GCD』详尽总结
    

     iOS 多线程-GCD
    

     第80题JAVA高级技术-多线程14（闭锁和栅栏)
    
       
   
  
    
   
        
       



     
     
     
 
    (c)2006-2024 SYSTEM All Rights Reserved  IT常识