ios——GCD基本使用

最新推荐文章于 2023-03-27 19:07:03 发布
最新推荐文章于 2023-03-27 19:07:03 发布
阅读量455 收藏 3
点赞数
分类专栏： 笔记 文章标签： ios
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fengyuyxz/article/details/114835909
版权
GCD基本概念
  1. 什么是GCD？
    全称是Grand Central Dispatch，翻译为中央调度；纯C实现，提供了非常强大的函数。
  2. GCD的优势
    • GCD是苹果公司为多核并行运算提出的解决方案
    • GCD会自动利用更多的CPU内核（如双核、四核等）
    • GCD会自动管理线程的生命周期(线程创建、任务调度、线程销毁)
    • 程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码
任务和队列

理解GCD中核心的两个概念

  1. 任务：执行什么操作（下载图片、耗时循环等）
  2. 队列：用来存放任务（程序中不可能有一个任务，比如下载多张图片等）
GCD的使用

使用GCD有两个步骤

  • 定制任务
    确定想做的事情
  • 将任务添加到队列中
    GCD会自动将队列中的任务取出，放到对应的线程中执行
    任务的取出遵循队列的FIFO原则：先进先出，后进后出
执行任务

GCD中有2个用来执行任务的常用函数

  1. 用同步的方式执行
    dispatch_sync(dispatch_queue_t _Nonnull queue, ^(void)block);
  2. 用异步方式执行
    dispatch_async(dispatch_queue_t _Nonnull queue, ^(void)block);
    参数：dispatch_queue_t:队列，将任务加入到哪个队列
    参数：block 封装任务的，执行任务的blcok
  • 同步和异步的区别
    同步：只能在当前线程中执行任务，不具备开启新线程的能力
    异步：可以在新的线程中执行任务，具备开启新线程的能力
队列的类型

GCD的队列可以分为2大类型

  1. 并发队列(Concurrent Dispatch Queue)
    • 可以让多个任务并发执行（自动开启多个线程同时执行任务）
    • 并发功能只有在异步dispatch_sync函数下才有效
  2. 串行队列(Serial Dispatch Queue)
    • 让任务一个接一个的执行
总结容易混淆的术语

  • 四个容易混淆术语：同步、异步、并发、串行
    同步和异步主要影响：能不能开启新线程

    • 同步：只能在当前线程中执行任务，不具备开启新线程的能力
    • 异步：可以在新的线程中执行任务，具备开启新线程的能力
      并发和串行的主要影响：任务的执行方式
    • 并发：允许多个任务并发执行（同时）
    • 串行：任务一个接一个执行，一个任务执行完毕后，再执行下一个任务

    这里的同步、异步指的是GCD中的同步和异步函数，并发、串行指的是GCD中的队列

基本使用方式
  1. 异步
-(void)downloadImage{
    CFAbsoluteTime start = CFAbsoluteTimeGetCurrent();
    NSString *imageUrlStr=@"https://t7.baidu.com/it/u=139984722,3523412696&fm=193&f=GIF";
    NSURL *url = [NSURL URLWithString:imageUrlStr];
    NSError *error=nil;
    NSData *data = [NSData dataWithContentsOfURL:url options:NSDataReadingUncached
 error:&error];
    UIImage *image=nil;
    if (!error) {
        image=[UIImage imageWithData:data scale:[UIScreen mainScreen].scale];
    }
    CFAbsoluteTime end = CFAbsoluteTimeGetCurrent();
    
//    [self performSelectorOnMainThread:@selector(showImag:) withObject:image waitUntilDone:YES];
    //使用imageView可省略一步写showImage:方法
    [self.imageView performSelectorOnMainThread:@selector(setImage:) withObject:image waitUntilDone:NO];
    NSLog(@"%f",end-start);
    
}

1.异步函数并行队列，会开启多条线程，队列中的任务是并发执行

//异步函数+并行队列:
-(void)asyncConcurrent{
    //1. 创建队列
    //第一个参数：C语音字符串，标签
    //第二个参数：队列类型；DISPATCH_QUEUE_CONCURRENT并发对下列；DISPATCH_QUEUE_SERIAL串行队列
    dispatch_queue_t queue = dispatch_queue_create("com.threadDome.async", DISPATCH_QUEUE_CONCURRENT);
    //2. 1.封装任务->添加任务到队列中
    //第一个参数：队列
    //第二个参数：要执行的任务
   dispatch_async(queue, ^{
        NSLog(@"downloadImage1  = %@",[NSThread currentThread]);
        [self downloadImage];
    });
    
    dispatch_async(queue, ^{
        NSLog(@"downloadImage2  = %@",[NSThread currentThread]);
        [self downloadImage];
    });
    
    dispatch_async(queue, ^{
        NSLog(@"downloadImage3  = %@",[NSThread currentThread]);
        [self downloadImage];
    });
}

在这里插入图片描述

通过打印日志看出，执行顺序无序的说明是并发执行
2. 异步函数串行队列：开启新线程，任务串行执行

//异步函数+串行队列:
-(void)asyncSerial{
    //1. 创建队列
    //第一个参数：C语音字符串，标签
    //第二个参数：队列类型；DISPATCH_QUEUE_CONCURRENT并发对下列；DISPATCH_QUEUE_SERIAL串行队列
    dispatch_queue_t queue = dispatch_queue_create("com.threadDome.async", DISPATCH_QUEUE_SERIAL);
    //2. 1.封装任务->添加任务到队列中
    //第一个参数：队列
    //第二个参数：要执行的任务
    dispatch_async(queue, ^{
        NSLog(@"downloadImage1  = %@",[NSThread currentThread]);
//        [self downloadImage];
    });
    
    dispatch_async(queue, ^{
        NSLog(@"downloadImage2  = %@",[NSThread currentThread]);
//        [self downloadImage];
    });
    
    dispatch_async(queue, ^{
        NSLog(@"downloadImage3  = %@",[NSThread currentThread]);
//        [self downloadImage];
    });
}

在这里插入图片描述
由日志可看出，任务是串行执行，并是在同一个新线程中执行
3. 同步方法+并行队列:任务是串行执行，并是在当前线程中执行（哪个线程调用就是那个线程中）不会开启新线程

//同步函数+并行队列:
-(void)syncConcurrent{
    //1. 创建队列
    //第一个参数：C语音字符串，标签
    //第二个参数：队列类型；DISPATCH_QUEUE_CONCURRENT并发对下列；DISPATCH_QUEUE_SERIAL串行队列
    dispatch_queue_t queue = dispatch_queue_create("com.threadDome.async", DISPATCH_QUEUE_CONCURRENT);
    //2. 1.封装任务->添加任务到队列中
    //第一个参数：队列
    //第二个参数：要执行的任务
    dispatch_sync(queue, ^{
        NSLog(@"downloadImage1  = %@",[NSThread currentThread]);
//        [self downloadImage];
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"downloadImage2  = %@",[NSThread currentThread]);
//        [self downloadImage];
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"downloadImage3  = %@",[NSThread currentThread]);
//        [self downloadImage];
    });
}

在这里插入图片描述
4. 同步函数+串行队列：不会开启新线程，任务是串行执行。

//同步函数+串行队列:
-(void)syncSerial{
    //1. 创建队列
    //第一个参数：C语音字符串，标签
    //第二个参数：队列类型；DISPATCH_QUEUE_CONCURRENT并发对下列；DISPATCH_QUEUE_SERIAL串行队列
    dispatch_queue_t queue = dispatch_queue_create("com.threadDome.async", DISPATCH_QUEUE_SERIAL);
    //2. 1.封装任务->添加任务到队列中
    //第一个参数：队列
    //第二个参数：要执行的任务
    dispatch_sync(queue, ^{
        NSLog(@"downloadImage1  = %@",[NSThread currentThread]);
//        [self downloadImage];
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"downloadImage2  = %@",[NSThread currentThread]);
//        [self downloadImage];
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"downloadImage3  = %@",[NSThread currentThread]);
//        [self downloadImage];
    });
}

在这里插入图片描述

获取并发队列方式
  1. 通过dispatch_queue_create函数创建并发队列
  2. 获取全局并发队列dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_get_global_queue参数说明
    • 第一个参数：优先级：DISPATCH_QUEUE_PRIORITY_BACKGROUND（该优先级最低）
    • 第二个参数：为将来保留使用的标志。始终为该参数指定0
      使用dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)获得的并发队列，与1中创建的队列是等价的，区别是，1是实打实创建了一个队列。使用dispatch_get_global_queue是获取全局现有的一个队里（这个队列在GCD中本身就存在，并且对应有高优先级，默认优先级，低优先级，和后台优先级一共有四个并发队列），在ios6.0之前，在gcd中凡是带有creat、retain的函数都需要做一次release操作。而主队列和全局并发队列不需要我们手动release。ios6.0之后GCD已经被纳入到了ARC的内存管理范畴中，不用再手动release释放了。

注意：GCD开多少条线程由系统决定，系统决定开几条合适就开几条

获取串行队列

GCD中获取创新队列有2中途径

  1. 通过dispatch_queue_create函数创建串行队列
    dispatch_queue_create("com.threadDome.async", NULL)队列类型传递NULL或DISPATCH_QUEUE_SERIAL
  2. 使用主队列（和主线程相关的队列）
    • 主队列是GCD自带的一种特殊串行队列
    • 放在主队列中的任务，都会放到主线程执行

异步同步函数使用住队列

  1. 异步函数+主队列
    • 不会开启新线程,所有任务都在主线程执行，串行执行

异步函数：如果当前没有执行完毕，后面代码也能执行

//异步步函数+主队列:
-(void)asyncMainQueue{
    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_async(queue, ^{
        NSLog(@"downloadImage1----- %@",[NSThread mainThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"downloadImage2----- %@",[NSThread mainThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"downloadImage3----- %@",[NSThread mainThread]);
    });
}

在这里插入图片描述
4. 同步函数+主队列
同步函数不能再主队列中执行，会产生死锁
主队列特点：如果主队列发下当前主线程有任务执行那么主队列会暂停调用队列中的任务，直到主线程空闲为止

同步函数：立刻执行，如果没有执行完毕，那么后面的也别想执行

同步函数将任务加入主队列中，因同步函数是立刻执行必须等待代码执行完毕才能继续往下执行，主队列将任务取出来让主线程来执行它，而主线程又没空，这样就导致死锁。
解决方式：在其他子线程中执行

[NSThread detachNewThreadSelector:@selector(syncMainQueue) toTarget:self withObject:nil];



//异步步函数+主队列:
-(void)syncMainQueue{
    dispatch_queue_t queue = dispatch_get_main_queue();
    NSLog(@"star");
    dispatch_sync(queue, ^{
        NSLog(@"downloadImage1----- %@",[NSThread mainThread]);
    });

}

总结：

并发队列手动创建串行队列主队列
同步1.没有开启新线程;
2.串行执行任务		1.没有开启新线程;
2.串行执行任务		在主线程调用会死锁;
子线程执行：
1.没有开启新线程;
2.串行执行任务
异步1.开启新线程;
2.并发执行任务		1.开启新线程;
2.串行执行任务		1.不会开启新线程;
2.串行执行任务
GCD线程间的通讯

前面NSThread说过线程间通讯。GCD线程间通讯更简单，直接嵌套就行。

__weak typeof(self) weakSelf = self;
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSString *imageUrlStr=@"https://t7.baidu.com/it/u=139984722,3523412696&fm=193&f=GIF";
        NSURL *url = [NSURL URLWithString:imageUrlStr];
        NSError *error=nil;
        NSData *data = [NSData dataWithContentsOfURL:url options:NSDataReadingUncached
     error:&error];
        UIImage *image=nil;
        if (!error) {
            image=[UIImage imageWithData:data scale:[UIScreen mainScreen].scale];
        }
        dispatch_async(dispatch_get_main_queue(), ^{
            weakSelf.imageView.image=image;
        });
    });
GCD常用函数
  1. 延迟执行dispatch_after
/*第一个参数：DISPATCH_TIME_NOW 从现在开始计算时间
      第二个参数：延迟的时间  GCD的时间单位是纳秒所以需要乘以一个参数NSEC_PER_SEC
     */
    dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC));
    /*第二个参数队列*/
    dispatch_after(time, dispatch_queue_create(NULL, DISPATCH_QUEUE_CONCURRENT), ^{
        NSLog(@"GCD延迟咨询-%@",[NSThread currentThread]);
    });
  1. dispatch_once一次性代码，运用程序只会执行一次
static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        NSLog(@"GCD once");
    });
GCD 栅栏函数
  1. 什么是栅栏函数，有什么作用？
    dispatch_barrier_async和dispatch_barrier_sync栅栏函数，一个是同步一个是异步方法；
    作用：我们在做多任务并发执行时，如有task1、task2、task3、task4四个并发任务，通常任务执行是无序的也执行完成时间也不一致，但需要某个或某几个任务必须在其他任务完成后在执行，栅栏函数就起租用了，只要在需要等待其他任务执行完成后再执行的任务前，加上栅栏就能达到该目的。
    在使用栅栏函数时，apple官方明确规定栅栏函数只有在使用create函数自己创建的并发队列一起使用的时候才有效没有给出具体原因
    示例如下：
dispatch_queue_t queue = dispatch_queue_create("com.thread.dome", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        // 模拟耗时操作
        for (int i=0; i<100; i++) {
            NSLog(@"task1    ===   %d",i);
        }
    });
    dispatch_async(queue, ^{
        // 模拟耗时操作
        for (int i=0; i<100; i++) {
            NSLog(@"task2    ===   %d",i);
        }
    });
    
    dispatch_barrier_async(queue, ^{
        NSLog(@"========");
    });
    
    dispatch_async(queue, ^{
        // 模拟耗时操作
        for (int i=0; i<100; i++) {
            NSLog(@"task3    ===   %d",i);
        }
    });
    dispatch_async(queue, ^{
        // 模拟耗时操作
        for (int i=0; i<100; i++) {
            NSLog(@"task4    ===   %d",i);
        }
    });

注意：栅栏函数不能使用全局队列，否则无效

GCD快速迭代

迭代就是一个for循环，通常循环是同步串行执行的。GCD快速迭代是异步并发执行的，执行速度更快。

函数名为dispatch_apply，函数接收三个参数，参数含义如下：

  • 第一个参数：循环总次数
  • 第二个参数：队列类型，必须是并发队列，串行队列无意义，主队列会造成死锁。
  • 第三个参数：执行任务的block
/*
     第一个参数：循环总次数
     第二个参数：队列类型，必须是并发队列，串行队列无意义，主队列会造成死锁。
     第三个参数：执行任务的block
     */
    dispatch_apply(10, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^(size_t index) {
        NSLog(@"%zu ==%@",index,[NSThread currentThread]);
    });

GCD的快速迭代对耗时操作有奇效

队列组

队列组的作用和栅栏函数有点相似，也是控制任务执行,例如，有个需求，有三个并发任务，我需要知道这三个任务都执行完后在执行其他的任务，这时队列组就起到作用了。

使用队列有如下步骤

  1. 创建并发队列
  2. 创建队列组
  3. 使用队列函数
  4. 在需要第地方添加队列通知函数执行任务
    其中涉及到的类型和函数有，dispatch_group_t gorup = dispatch_group_create()、dispatch_group_async、dispatch_group_notify
    其中dispatch_group_async执行了如下功能
    1.封装任务
    2.把任务添加到队列中
    3.会监听任务的执行情况，通知到group
    使用示例：
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    
    dispatch_group_t gorup = dispatch_group_create();
 
    dispatch_group_async(gorup, queue, ^{
        NSLog(@"task1 ------%@",[NSThread currentThread]);
    });
    
    dispatch_group_async(gorup, queue, ^{
        NSLog(@"task2 ------%@",[NSThread currentThread]);
    });
    dispatch_group_async(gorup, queue, ^{
        NSLog(@"task3 ------%@",[NSThread currentThread]);
    });
    dispatch_group_notify(gorup, queue, ^{
        NSLog(@"其他任务执行完毕了");
    });
第二种通过函数对的形式

还有一种实现队列组完成情是使用函数对的形式，涉及的函数如下：

  1. dispatch_group_enter在该函数方法后面的异步任务会被纳入到队列组的监听范围，进入群组
  2. dispatch_group_leave告知group任务完成了离开群组
//1.创建队列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    //2.创建队列组
    dispatch_group_t group = dispatch_group_create();
    //3. 在该函数方法后面的异步任务会被纳入到队列组的监听范围，进入群组
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        NSLog(@"task1 -- %@",[NSThread currentThread]);
        dispatch_group_leave(group);
    });
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        NSLog(@"task2 -- %@",[NSThread currentThread]);
        dispatch_group_leave(group);
    });
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        NSLog(@"task2 -- %@",[NSThread currentThread]);
        dispatch_group_leave(group);
    });
    dispatch_group_notify(group, queue, ^{
        NSLog(@" 其他任务执行完毕了 ");
    });
    NSLog(@"=== end ====");

注意：dispatch_group_enter和dispatch_group_leave必须成对使用
也可将dispatch_group_notify替换dispatch_group_wait函数，在dispatch_group_wait后面加其他任务完成后的执行代码。
dispatch_group_wait参数说明：
1.队列组
2.时间：dispatch_time_t,有两个宏DISPATCH_TIME_FOREVER死等知道队列组中所有任务执行完毕后才执行。
下面是一个下载两张图片冰进行合成的示例：

-(void)synteticImage{
    CFAbsoluteTime start = CFAbsoluteTimeGetCurrent();
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_t group=dispatch_group_create();
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        [self downLoadImage:@"https://t7.baidu.com/it/u=4086399150,3589527948&fm=193&f=GIF" completion:^(UIImage *img) {
            self.image1 = img;
            dispatch_group_leave(group);
        }];
    });
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        [self downLoadImage:@"https://t7.baidu.com/it/u=4042286517,3975636867&fm=193&f=GIF" completion:^(UIImage *img) {
            self.image2 = img;
            dispatch_group_leave(group);
        }];
    });
    dispatch_group_notify(group, queue, ^{
        UIGraphicsBeginImageContext(CGSizeMake(400, 300));
        [self.image1 drawInRect:CGRectMake(0, 0, 200, 200)];
        [self.image2 drawInRect:CGRectMake(200, 0, 200, 200)];
        UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
        UIGraphicsEndImageContext();
        [self.imageView performSelectorOnMainThread:@selector(setImage:) withObject:image waitUntilDone:NO];
        CFAbsoluteTime end=CFAbsoluteTimeGetCurrent();
        NSLog(@"time = %f",end-start);
    });
}
-(void)downLoadImage:(NSString *)imgUrlStr completion:(void(^)(UIImage *img))block{
    CFAbsoluteTime start = CFAbsoluteTimeGetCurrent();
    NSURL *imgURL = [NSURL URLWithString:imgUrlStr];
    NSData *imgData = [NSData dataWithContentsOfURL:imgURL];
    UIImage *img = [UIImage imageWithData:imgData];
    CFAbsoluteTime end = CFAbsoluteTimeGetCurrent();
    NSLog(@"donwloadImage time %f",end-start);
    if (block) {
        block(img);
    }
}

或

-(void)synteticImage{
    CFAbsoluteTime start = CFAbsoluteTimeGetCurrent();
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_t group=dispatch_group_create();
    
    dispatch_group_async(group,queue, ^{
        self.image1= [self downLoadImage:@"https://t7.baidu.com/it/u=4086399150,3589527948&fm=193&f=GIF"];
    });
    
    dispatch_group_async(group,queue, ^{
        self.image2=[self downLoadImage:@"https://t7.baidu.com/it/u=4042286517,3975636867&fm=193&f=GIF"];
    });
    dispatch_group_notify(group, queue, ^{
        UIGraphicsBeginImageContext(CGSizeMake(400, 300));
        [self.image1 drawInRect:CGRectMake(0, 0, 200, 200)];
        [self.image2 drawInRect:CGRectMake(200, 0, 200, 200)];
        UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
        UIGraphicsEndImageContext();
        [self.imageView performSelectorOnMainThread:@selector(setImage:) withObject:image waitUntilDone:NO];
        CFAbsoluteTime end=CFAbsoluteTimeGetCurrent();
        NSLog(@"time = %f",end-start);
    });
}
-(UIImage *)downLoadImage:(NSString *)imgUrlStr{
    CFAbsoluteTime start = CFAbsoluteTimeGetCurrent();
    NSURL *imgURL = [NSURL URLWithString:imgUrlStr];
    NSData *imgData = [NSData dataWithContentsOfURL:imgURL];
    UIImage *img = [UIImage imageWithData:imgData];
    CFAbsoluteTime end = CFAbsoluteTimeGetCurrent();
    NSLog(@"donwloadImage time %f",end-start);
    return img;
}

NSOperation简介

fengyuyxz
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
iOS多线程开发——NSThread浅析
01-06
在iOS开发中，多线程的实现方式主要有三种，NSThread、NSOperation和GCD，我前面博客中对NSOperation和GCD有了较为详细的实现，为了学习的完整性，今天我们主要从代码层面来实现NSThread的使用。案例代码上传至 ...
iOS—GCD详解
qq_45836906的博客
08-05 4994
文章目录多线程编程进程线程线程与进程的关系多线程编程多线程编程的问题GCD什么是GCDGCD任务和队列GCD的使用步骤队列的创建队列的获取任务的创建方法任务与队列不同组合方式的区别同步执行 + 并发队列异步执行 + 并发队列同步执行 + 串行队列异步执行 + 串行队列同步执行 + 主队列在主线程中调用 同步执行+主队列在其他线程中调用 同步执行+主队列异步执行 + 主队列GCD其他方法GCD栅栏方法：dispatch_barrier_asyncGCD延时执行方法：dispatch_afterGCD 一次性代
iOS多线程之GCD
wywinstonwy的专栏
05-31 2931
GCD（Grand Central Dispatch），是有Apple公司开发的一个多核编程的解决方案，用以优化应用程序支持多核处理器，是基于线程模式之上执行并发任务。 GCD的优点 1.利用设备多核进行并行运算 2.GCD自动充分使用设备的CPU内核 3.GCD自动管理线程的生命周期（线程创建、线程调度、线程销毁） 4.使用简单 GCD任务和队列 任务：就是执行操作，即可以执行的代码；执行任务有两种方式：同步 和 异步。 同步（sync）：阻塞线程： 同步添加任务到指定的队列中，
IOS 多线程：『GCD』详尽总结
假装你是大灰狼的专栏
12-14 1148
1. GCD 简介 什么是 『GCD』 ？我们先来看看百度百科的解释简单了解下相关概念。 引自 百度百科 Grand Central Dispatch（GCD） 是 Apple 开发的一个多核编程的较新的解决方法。它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。它是一个在线程池模式的基础上执行的并发任务。在 Mac OS X 10.6 雪豹中首次推出，也可在 iOS 4 及以上版本使用。 那为什么我们要使用 GCD 呢？ 因为使用 GCD 有很多好处啊，具体如下： GCD 可用于多核的并
【iOS开发】—— GCD
weixin_50990189的博客
03-19 3015
文章目录GCD概述什么是GCD？多线程编程GCD的APIDispatch Queuedispatch_queue_createMain Dispatch Queue/Global Dispatch Queuedispatch_set_target_queuedispatch_after GCD概述 什么是GCD？ GCD（Grand Center Dispatch）是异步执行任务的技术之一。开发者定义想执行的任务并且追加到适当的Dispatch Queue中，GCD就能生成必要的线程并计划执行任务。 多线程
【iOS-多线程【一】GCD【一】
weixin_61639290的博客
02-07 578
上周学习的BLOCK是看了小蓝书，上面讲的确实不明白，经过指点，对于小蓝书的第六章-块与大中枢派发还需要详细学习另一本书，这次先补充GCD，block打算到学校进行一个详细的学习本篇文章宗旨是记录学习，如遇错误敬请评论区斧正。GCD的全称是Grand Central Dispatch，是异步执行任务的技术之一。它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。
iOS高级程序员进阶——多线程编程核心技术模式篇
06-18
在iOS开发中，实现多线程的的方式有很多种，常用的有pthread、NSThread、GCD与NSOperation。在实际应用中，多线程技术也有着非常多的使用场景，比如异步的网络请求、异步的图片加载、后台执行复杂任务等等。 在iOS...
ios小项目——新浪微博客户端
04-28
ios小项目——新浪微博客户端 用的都是ios5的新东西 ARC storyboard segue 也加入了GCD与coredata 还有些需要改进的地方 有兴趣的朋友自己改进咯 只是作为练习的一个小东西 希望对你也有所帮助
在IOS中为什么使用多线程及多线程实现的三种方法
01-21
多线程是一个比较轻量级的方法来实现单个应用程序内多个代码执行路径。 在系统级别内，程序并排执行，程序分配到每个程序的执行时间是基于该...有些程序是一条直线，起点到终点——如简单的hello world，运行打印完，
iOS GCD详解
12-04
iOS GCD详解，让你了解并掌握GCD的使用
iOS-GCD详解及简单使用
09-01
主要介绍了iOS-GCD详解的相关资料,并附简单的实例代码，帮助大家学习理解此部分的知识,需要的朋友可以参考下
iOS --GCD详解
08-24
1、异步并发队列（同时开启N个线程） // [self asynchronousConcurrent]; 2、异步串行队列（会开启线程，但是只开启一个线程） // [self asynchronousSerial] 3、同步并发队列（不会开启新的线程，并发队列失去并发的功能） // [self synchronousConcurrent] 4、同步串行队列（不会开启新的线程） // [self synchronousSerial]
iOS GCD 开发教程 完整版
03-19
iOS GCD 开发教程 完整版 有需要的同学看看 iOS GCD 开发教程 完整版 有需要的同学看看 iOS GCD 开发教程 完整版 有需要的同学看看
iOS多线程——GCD学习总结
cyberjack的博客
03-27 1269
iOS GCD详解
【iOS】—— 深入了解GCD
m0_55124878的博客
08-05 438
百度：Grand Central Dispatch（GCD） 是 Apple 开发的一个多核编程的较新的解决方法。它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。它是一个在线程池模式的基础上执行的并发任务。在 Mac OS X 10.6 雪豹中首次推出，也可在 iOS 4 及以上版本使用。苹果官方：Grand Central Dispatch(GCD) 是异步执行任务的技术之一。一般将应用程序中记述的线程管理用的代码在系统级实现。...
iOS多线程之GCD用法详解
如鱼得水的专栏
08-18 698
在上一篇讲解了iOS开发的三种多线程实现方式的特点和用法，在这一篇主要讲解一下GCD的用法。 GCD（Grand Central Dispatch）又叫大中央调度，它对线程操作进行了封装，加入了很多新的特性，内部进行了效率优化，提供了简洁的C语言接口，使用更加简单高效，也是苹果公司推荐的方式。 特点： GCD 可用于多核的并行运算 GCD 会自动利用更多的 CPU 内核（比如双核、四核） GCD...
iOS开发中的四种GCD
iOS15011015的博客
04-07 246
GCD的核心：将操作/任务放到队列中。
iOS GCD定时器
最新发布
08-26
iOS中使用GCD（Grand Central Dispatch）可以实现定时器功能。下面是一个简单的示例代码： ```swift // 创建一个队列 let queue = DispatchQueue.global() // 创建一个定时器，每隔1秒执行一次 let timer = DispatchSource.makeTimerSource(queue: queue) timer.schedule(deadline: .now(), repeating: .seconds(1)) timer.setEventHandler { // 定时器触发时执行的代码 print("Timer fired") } // 启动定时器 timer.resume() ``` 在上面的代码中，我们使用`DispatchSource.makeTimerSource`方法创建了一个定时器对象，然后设置了定时器的触发时间间隔为1秒，以及触发时执行的代码。最后通过调用`resume`方法启动了定时器。 当不再需要使用定时器时，可以调用`cancel`方法来停止定时器的运行。 需要注意的是，定时器会在创建它的队列上运行，所以如果你希望在主线程上执行某些操作，可以使用`DispatchQueue.main`来创建队列。另外，记得在使用完定时器后销毁它，避免内存泄漏。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值