iOS多线程——GCD概念篇

最新推荐文章于 2024-03-23 17:09:43 发布
置顶 最新推荐文章于 2024-03-23 17:09:43 发布
阅读量1.3k 收藏
点赞数 1
分类专栏： # 多线程 文章标签： GCD 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Z1591090/article/details/89159860
版权

简单介绍

什么是GCD？

全称是Grand Central Dispatch，可译为“牛逼的中枢调度器”

纯C语言，提供了非常多强大的函数

GCD的优势

GCD是苹果公司为多核的并行运算提出的解决方案

GCD会自动利用更多的CPU内核（比如双核、四核）

GCD会自动管理线程的生命周期（创建线程、调度任务、销毁线程）

在使用GCD时，只需要把任务（通常封装在一个Block中）添加到一个队列中执行，只需按一下步骤执行

1.在Block中定义需要执行的任务内容
2.把任务添加到队列queue

3.提示
(1)GCD存在于libdispatch.dylib这个库中，这个调度库包含了GCD的所有的东西，但任何IOS程序，默认就加载了这个库，在程序运行的过程中会动态的加载这个库，不需要我们手动导入。
在这里插入图片描述
点击+a按钮，可以导入框架。
在这里插入图片描述
(2)GCD是纯C语言的，因此我们在编写GCD相关代码的时候，面对的函数，而不是方法。
(3)GCD中的函数大多数都以dispatch开头。

任务和队列

GCD中有2个核心概念

任务：执行什么操作

同步任务

执行任务会在当前线程中执行，当前线程有可能是主线程，也可能是子线程

dispatch_sync(dispatch_queue_t queue, DISPATCH_NOESCAPE dispatch_block_t block);
  • 必须等待当前语句执行完毕，才会执行下一条语句
  • 不会开启线程
  • 在当前block的任务

异步任务

执行任务，会在另外的线程执行，可能会创建新的任务

dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

  • 不用等待当前语句的执行完毕，就可以执行下一条语句
  • 会开启新的线程执行block的任务
  • 异步是多线程的代名词

GCD执行任务

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

说明：把右边的参数（任务）提交给左边的参数（队列）进行执行。

（1）用同步的方式执行任务 dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);

参数说明：

queue：队列

block：任务

（2）用异步的方式执行任务 dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

2.同步和异步的区别

同步：在当前线程中执行

异步：在另一条线程中执行

队列：用来存放任务

请添加图片描述

任务始终在主线程上执行，与更新UI相关的操作在主队列完成

并行队列

并行对列可以在多个线程之间分配执行，分配原则由GCD控制，因此并行队列的任务虽然先进先出原则，但由于分配到不同的线程中，因此完成时间可能不同即：后分配的有可可能先完成

串行队列

串行顺序是一个一个的完成，在一个线程执行 主队列：主队列也是串行队列，主队列任务都在主线程中完成

GCD的使用就2个步骤

（1）定制任务

（2）确定想做的事情

将任务添加到队列中，GCD会自动将队列中的任务取出，放到对应的线程中执行

提示：任务的取出遵循队列的FIFO原则：先进先出，后进后出
请添加图片描述

GCD队列

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

（1）并发队列（Concurrent Dispatch Queue）

可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）并发功能只有在异步（dispatch_async）函数下才有效
在这里插入图片描述

（2）串行队列（Serial Dispatch Queue）

让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）
在这里插入图片描述

2.补充说明

有4个术语比较容易混淆：同步、异步、并发、串行

同步和异步决定了要不要开启新的线程

  • 同步：在当前线程中执行任务，不具备开启新线程的能力
  • 异步：在新的线程中执行任务，具备开启新线程的能力

并发和串行决定了任务的执行方式

并发：多个任务并发（同时）执行

串行：一个任务执行完毕后，再执行下一个任务

3.串行队列

GCD中获得串行有2种途径

（1）使用dispatch_queue_create函数创建串行队列

dispatch_queue_t dispatch_queue_create(const char *label, dispatch_queue_attr_t attr); // 队列名称， 队列属性，一般用NULL即可

示例：

dispatch_queue_t queue = dispatch_queue_create(“wendingding”, NULL); // 创建

dispatch_release(queue); // 非ARC需要释放手动创建的队列

（2）使用主队列（跟主线程相关联的队列）

主队列是GCD自带的一种特殊的串行队列,放在主队列中的任务，都会放到主线程中执行

使用dispatch_get_main_queue()获得主队列

示例：

dispatch_queue_t queue = dispatch_get_main_queue();

4.并发队列

GCD默认已经提供了全局的并发队列，供整个应用使用，不需要手动创建

使用dispatch_get_global_queue函数获得全局的并发队列

dispatch_queue_t dispatch_get_global_queue(dispatch_queue_priority_t priority,unsigned long flags); // 此参数暂时无用，用0即可
示例：

这个参数是留给以后用的，暂时用不上，传个0。
第一个参数为优先级，这里选择默认的。获取一个全局的默认优先级的并发队列。
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); // 获得全局并发队列

在这里插入图片描述

说明：全局并发队列的优先级

#define DISPATCH_QUEUE_PRIORITY_HIGH 2 // 高

#define DISPATCH_QUEUE_PRIORITY_DEFAULT 0 // 默认（中）

#define DISPATCH_QUEUE_PRIORITY_LOW (-2) // 低

#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN // 后台

5.各种队列的执行效果
在这里插入图片描述

任务与队列代码示例

异步就是彼此独立,在等待某事件的过程中继续做自己的事，不需要等待这一事件完成后再工作。在大多数情况下，执行异步任务时会创建新的线程（在调用block代码块或开启定时器时一般是不会开启新的线程的），所以说线程的开启是和任务息息相关的。异步是最终目的,多线程只是我们实现异步的一种手段。异步是当一个调用请求发送给被调用者,而调用者不用等待其结果的返回而可以做其它的事情

异步任务 + 并行队列

把异步任务放到并行队列进行执行，异步任务会在不同线程中执行，

 dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(queue, ^{
        // 追加任务1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    dispatch_async(queue, ^{
        // 追加任务2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    dispatch_async(queue, ^{
        // 追加任务3
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });

请添加图片描述

开启了三条线程，异步任务在不同的线程中执行

异步任务 + 串行队列

特点：会开启新线程，但是因为任务是串行的，执行完一个任务，再执行下一个任务。

  dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);
    
    dispatch_async(queue, ^{
        // 追加任务1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    dispatch_async(queue, ^{
        // 追加任务2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    dispatch_async(queue, ^{
        // 追加任务3
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });

请添加图片描述

任务是按照顺序执行了只开启了一条子线程

异步任务 + 主队列

把异步任务放到主队列，由于主队列是一个特殊的串行队列，因此任务是串行执行的，但由于主队列对应1的线程，因此异步任务，也不会创建新的线程

请添加图片描述

主队列无论同步还是异步都不会开启新的线程，
并且任务按照顺序执行

需求：
iOS app在被用户切换到后台的时候就会处于挂起状态，如果这时你的应用正在进行一个任务中并且需要额外的时间来完成这个任务

调用两个方法里面的任何一个方法来延迟系统暂停你的应用，并申请额外的时间来完成未完成的任务。注意，当你完成任务后，必须调用endBackgroundTask:方法来告诉系统任务完成了，可以暂停应用了。或者，当你的应用回到前台了，就必须要结束这个任务了。

 dispatch_queue_t mainQueue = dispatch_get_main_queue();
    __block typeof(self)bself = self;
    dispatch_async(mainQueue, ^(void) {
        if (bself != nil){
            [[UIApplication sharedApplication] endBackgroundTask:bself.backgroundIdentifier];
            bself.backgroundIdentifier = UIBackgroundTaskInvalid;
        }
    });

同步任务不会开启新的线程，按顺序执行，执行完一个再执行下一个，需要等待、协调运行；

同步任务 + 并行

同步任务的执行，是在当前线程中执行的，因此同步任务放在并列中执行，由于只有1个线程，任务也是一个一个按顺序执行（串行执行）的不会死锁

需求，删除数据库的数据

 dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_sync(queue, ^{
        // 追加任务1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    dispatch_sync(queue, ^{
        // 追加任务2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    dispatch_sync(queue, ^{
        // 追加任务3
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    NSLog(@"syncConcurrent---end");
}

请添加图片描述

同步任务的执行，是在当前线程中执行的，
因此同步任务放在并列中执行，由于只有1个线程，任务也是一个一个按顺序执行（串行执行）的不会死锁

同步任务 + 串行队列

同步任务放在串行队列中执行，任务会在当前线程依次执行
需求：
保存数据到文件里面


 NSString *filePath = @"文件地址";
 
        dispatch_sync([self p_getFileHandleQueue], ^{
            fileData = [NSData dataWithContentsOfFile:filePath];
        });
    
  
- (dispatch_queue_t)p_getFileHandleQueue
{
    static dispatch_queue_t queue = NULL;
    static dispatch_once_t once;
    dispatch_once(&once, ^{
        //串行队列
        queue = dispatch_queue_create("文件的名称", NULL);
    });
    return queue;
}

同步任务 + 主队列

这种情况，主线程会被阻塞，程序会挂死，不能使用

（4）用同步函数往串行队列中添加任务
（6）小结

说明：

  • 同步函数不具备开启线程的能力，无论是什么队列都不会开启线程；
  • 异步函数具备开启线程的能力，开启几条线程由队列决定（串行队列只会开启一条新的线程，并发队列会开启多条线程）。

同步函数

（1）并发队列：不会开线程

（2）串行队列：不会开线程

异步函数

（1）并发队列：能开启N条线程

（2）串行队列：开启1条线程

补充：

凡是函数中，各种函数名中带有create\copy\new\retain等字眼，都需要在不需要使用这个数据的时候进行release。
GCD的数据类型在ARC的环境下不需要再做release。
CF（core Foundation）的数据类型在ARC环境下还是需要做release。
异步函数具备开线程的能力，但不一定会开线程

相关面试题

GCD有哪些方法api

  • 队列
dispatch_get_main_queue()
dispatch_get_global_queue()
dispatch_queue_create()
  • 执行
dispatch_async()
dispatch_sync()
dispatch_after()
dispatch_once()
dispatch_apply()
dispatch_barrier_async()
dispatch_barrier_sync()
  • 调度组
dispatch_group_create()
dispatch_group_async()
dispatch_group_enter()
dispatch_group_leave()
dispatch_group_notify()
dispatch_group_wait()
  • 信号量
dispatch_semaphore_create()
dispatch_semaphore_wait()dispatch_semaphore_signal()
  • 调度资源
dispatch_source_create()
dispatch_source_set_timer()
dispatch_source_set_event_handler()
dispatch_resume()
dispatch_suspend()
dispatch_source_cancel()
dispatch_source_testcancel()
dispatch_source_set_cancel_handler()

如何实现同步，有多少方式就说多少

  • dispatch_sync()
  • dispatch_barrier_sync()
  • dispatch_group_create() + dispatch_group_wait()
  • dispatch_apple()
  • dispatch_semaphore_create() + dispatch_semaphore_wait()
  • NSOpertaion start
  • NSOperationQueue.maxConcurrentOperationCount = 1
  • 锁 pthread_mutex
  • NSLock
  • NSRecursiveLock
  • NSConditionLock & NSCondition

程序题1

- (void)textDemo1{
    dispatch_queue_t queue = dispatch_queue_create("question1", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"1");
    dispatch_async(queue, ^{
        NSLog(@"2");
        // 异步
        dispatch_async(queue, ^{
            NSLog(@"3");
        });
        NSLog(@"4");
    });
    NSLog(@"5");

}

答案

1-5-2-4-3

分析

  • DISPATCH_QUEUE_CONCURRENT 因为是并发队列所以不会阻塞
  • 1 先打印，
  • 5与2任务的复杂度是相同的，异步是耗时的所以5先执行然后执行2
  • 3与4任务3在异步里面所以先执行4

思考

如果特殊情况2也可能先执行，比如当前主队列，卡顿延迟，回不来

程序题2

- (void)textDemo1{
    dispatch_queue_t queue = dispatch_queue_create("question1", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"1");
    dispatch_async(queue, ^{
        NSLog(@"2");
        // 同步
        dispatch_sync(queue, ^{
            NSLog(@"3");
        });
        NSLog(@"4");
    });
    NSLog(@"5");

}

答案

1-5-2-3-4

分析

  • 1 先打印，
  • 5与2任务的复杂度是相同的，异步是耗时的所以5先执行然后执行2
  • 3与4任务3在同步里面，同步是block先执行完才往下执行，所以3先执行完，4 在执行

思考

如果特殊情况2也可能先执行，比如当前主队列，卡顿延迟，回不来

程序题3

- (void)textDemo2{
    // 串行队列
    dispatch_queue_t queue = dispatch_queue_create("question2", NULL);
    NSLog(@"1");
    // 异步函数
    dispatch_async(queue, ^{
        NSLog(@"2");
        // 同步
        dispatch_sync(queue, ^{
            NSLog(@"3");
        });
        NSLog(@"4");
    });
    NSLog(@"5");
}

答案
请添加图片描述

分析

  • 这个是串行队列: #define DISPATCH_QUEUE_SERIAL NULL
  • 先出来的是主队列的 1-5
  • 然后输出 2

请添加图片描述

  • 块任务添加3任务，然后3任务等待4任务执行完，4任务等待块任务执行完，块任务等待3任务执行完
  • 这样就形成了死锁

延展

NSLog(@“4”); 把它注释还会死锁吗？

会。 因为等待的不是NSLog(@“4”) 而是dispatch_async(queue, ^{
NSLog(@“2”);
// 同步
dispatch_sync(queue, ^{
NSLog(@“3”);
});
NSLog(@“4”);
}
这个任务块执行完毕

程序题4

- (void)textDemo3{
// 并发队列
    dispatch_queue_t queue = dispatch_queue_create("question3", DISPATCH_QUEUE_CONCURRENT);
// 1，2 没有顺序
    dispatch_async(queue, ^{ // 耗时
        NSLog(@"1");
    });
    dispatch_async(queue, ^{
        NSLog(@"2");
    });
    
    // 同步
    dispatch_sync(queue, ^{
        NSLog(@"3");
    });
    
    NSLog(@"0");

    dispatch_async(queue, ^{
        NSLog(@"7");
    });
    dispatch_async(queue, ^{
        NSLog(@"8");
    });
    dispatch_async(queue, ^{
        NSLog(@"9");
    });
    
}

分析

  • 1，2 没有顺序

  • 0 优先于（7，8，9），（7，8，9）没有顺序

  • 1，2，3 没有顺序，3堵塞的是 dispatch_sync(queue, ^{
    NSLog(@“3”);
    }) {} 之后，所以1，2，3没有顺序

  • 0必须在3之后

GCD有哪些队列，默认提供哪些队列

主队列

`dispatch_get_main_queue()`

1.专门用来在线程上调度任务的串行队列
2.不会开启线程
3.如果当前主线程正有任务执行，那么无论主队列中添加了什么任务，都不会被调度
4.主队列创建在mian函数之前

全局并发队列


> `dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)`
> 
> 队列优先级从高到底为：
> 
> `DISPATCH_QUEUE_PRIORITY_HIGH`
> 
> `DISPATCH_QUEUE_PRIORITY_DEFAULT`
> 
> `DISPATCH_QUEUE_PRIORITY_LOW`
> 
> `DISPATCH_QUEUE_PRIORITY_BACKGROUND`
  1. 全局队列是一个并发队列
  2. 在使用多线程开发时，如果对队列没有特殊要求，在执行异步任务时，可以直接使用全局队列

自定义队列（串行 Serial 与并行 Concurrent）


> `dispatch_queue_create("这里是队列名字", DISPATCH_QUEUE_SERIAL)`
> 
> 串行 `DISPATCH_QUEUE_SERIAL`
> 
> 并行 `DISPATCH_QUEUE_CONCURRENT`

同步还是异步都是耗时的

performSelector

 dispatch_async(dispatch_get_global_queue(0, 0), ^{
        [self performSelector:@selector(test) withObject:nil];
    });

这里的 test 方法是不会去执行的，原因在于

performSelector 要创建任务是要提交到runLoop上去的
而 gcd 底层创建的线程是默认没有开启对应 runloop 的，所有这个方法就会失效。

解决办法

  • dispatch_get_global_queue 改成主队列，由于主队列所在的主线程是默认开启了 runloop 的
  • 就会去执行(将 dispatch_async 改成同步，因为同步是在当前线程执行，那么如果当前线程是主线程，test
Z苗
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数论之指数和原根
只想躺平不想动
12-06 1787
涉及初等数论中指数, 原根的概念以及若干例子, 相关的定理.
iOS—GCD详解
qq_45836906的博客
08-05 5451
文章目录多线程编程进程线程线程与进程的关系多线程编程多线程编程的问题GCD什么是GCDGCD任务和队列GCD的使用步骤队列的创建队列的获取任务的创建方法任务与队列不同组合方式的区别同步执行 + 并发队列异步执行 + 并发队列同步执行 + 串行队列异步执行 + 串行队列同步执行 + 主队列在主线程中调用 同步执行+主队列在其他线程中调用 同步执行+主队列异步执行 + 主队列GCD其他方法GCD栅栏方法：dispatch_barrier_asyncGCD延时执行方法：dispatch_afterGCD 一次性代
【iOS】GCD详解
最新发布
cheng_lin0201的博客
03-23 1077
详解GCD
iOS多线程--彻底学会多线程之『GCD』
qq_20176153的博客
06-26 351
GCD 文章目录 GCD简介任务和队列GCD的使用步骤 队列的创建方法任务的创建方法 GCD的基本使用 并发队列 + 同步执行并发队列 + 异步执行串行队列 + 同步执行串行队列 + 异步执行主队列 + 同步执行主队列 + 异步执行 GCD线程之间的通讯GCD的其他方法 GCD的栅栏方法dispatch_barrier_asyncGCD的延时执行方法dispa
iOS-GCD详解
wtl1804的博客
08-20 394
文章目录进程、线程、上下文进程上下文线程基本概念任务、队列理解并发和并行的概念GCD使用队列的创建队列获取dispatch_queue_set_specific和dispatch_get_specific设置标识符和获取标识任务创建其他APIGCD 栅栏方法：dispatch_barrier_asyncGCD 延时执行方法：dispatch_afterGCD 一次性代码（只执行一次）：dispatch_onceGCD 快速迭代方法：dispatch_applyGCD 队列组：dispatch_groupdi
iOS多线程--gcd篇
墨丘利的博客
03-24 355
    这几天在看iOS-gcd相关的书籍,做一个简单的总结    1): 队列     分为串行队列和并行队列:  dispatch_queue_create("serialQueue",nil),这个方法总共有两个参数,第一个参数是这个队列的名称,第二个参数有两个值可以选择,分别是"DISPATCH_QUEUE_SERIAL","DISPATCH_QUEUE_CONCURRENT",前面一个表...
iOS多线程之GCD
powerof10的博客
01-29 314
一、基本概念 GCD 全称 Grand Central Dispatch，又称大中央调度，对线程操作进行了封装并提供简洁的C语言接口 1. 串行队列与并发队列 串行队列：任务按 FIFO 的顺序执行，同一时间只执行一个任务，按FIFO的顺序执行完毕 并发队列：任务按 FIFO 的顺序开始执行，同一时间可执行多个任务，任务完成的顺序不可预测 2. 同步派发和异步派发 GCD将 block 任务块派发到指定队列中执行，有同步、异步两种方式 1. 同步派发 dispatch_sync 会阻塞当前线程
iOS多线程开发——NSThread浅析
09-02
本篇文章将深入浅析NSThread在iOS多线程开发中的应用。 首先，初始化并启动一个线程是NSThread的基本操作。在`viewWillAppear:`方法中，我们可以创建一个新的线程实例，通过`initWithTarget:selector:object:`方法...
iOS高级程序员进阶——多线程编程核心技术模式篇
06-18
在iOS开发中，实现多线程的的方式有很多种，常用的有pthread、NSThread、GCD与NSOperation。在实际应用中，多线程技术也有着非常多的使用场景，比如异步的网络请求、异步的图片加载、后台执行复杂任务等等。 在iOS...
IOS应用源码——多线程.zip
10-14
在iOS应用开发中，多线程是一个至关重要的概念，它使得应用程序可以同时执行多个任务，提升用户体验并优化系统...通过分析和学习"IOS应用源码——多线程.zip"中的源代码，你可以更深入地理解这些概念并在实践中运用。
iOS GCD介绍
liu_wentao的博客
05-22 362
作者刘文涛 转载请注明出处一、简单介绍1.什么是GCDGrand Central Dispatch
GCD小结
java开发指南博客 【转载】
08-01 152
0. Brief Introduction GCD，全称Grand Central Dispath，是苹果开发的一种支持并行操作的机制。它的主要部件是一个FIFO队列和一个线程池，前者用来添加任务，后者用来执行任务。 GCD中的FIFO队列称为dispatch queue，它可以保证先进来的任务先得到执行（但不保证一定先执行结束）。 通过与线程池的配合，dispatch queu...
ios学习路线—iOS高级(GCD)
Sunny博客
06-19 315
什么是 GCD GCD 是 libdispatch 的市场名称，而 libdispatch 作为 Apple 的一个库，为并发代码在多核硬件（跑 iOS 或 OS X ）上执行提供有力支持。它具有以下优点： 1.GCD 能通过推迟昂贵计算任务并在后台运行它们来改善你的应用的响应性能。 2.GCD 提供一个易于使用的并发模型而不仅仅只是锁和线程，以帮助我们避开并发陷阱。 3.GCD 具有在常见
iOS GCD
qiangshuting的博客
10-20 846
1.GCD的好处： GCD可用于多核的并行运算 会自动利用更多的CPU内核 GCD会自动管理线程的生命周期（创建线程，调度任务，销毁线程） 程序员只需告诉GCD想要执行什么任务，不需要任何线程管理代码 2.任务和队列 任务：执行操作 同步执行和异步执行 区别：是否等待队列任务的执行结束，以及是否具备开启新线程的能力。 同步执行： 只能在当前线程中执行任务，不具备开启新线程的能力。 异步执行： 异...
线程安全——锁
Z1591090的博客
07-19 1877
前言 多线程利用CPU多核的性质。能并行执行任务，提高效率。但随着多线程的使用，对于资源的静态以及数据的操作都可能存在风险，所以有必要在操作时保证线程安全。而线程的安全主要是依靠各种锁，锁的种类有很多，有各自的优缺点，需要开发者自己权衡利弊，选择合适的锁，来搭配多线程的使用。 NSLock ...
iOS多线程——GCD底层探索中（dispatch_async与dispatch_sync源码）
Z1591090的博客
08-04 1098
准备工作以及源码的下载在上一篇文章中 并发函数 dispatch_async 查看源码 dispatch_async(dispatch_queue_t // dq为队列，work为任务 void dispatch_async(dispatch_queue_t dq, dispatch_block_t work) { // 临时变量，参数 dispatch_continuation_t dc = _dispatch_continuation_alloc(); uintptr_t dc_flags =
多线程（GCD,NSOperation）
Z1591090的博客
07-16 667
多线程是软件开发中，不可避免的问题，是指从软件和硬件实现多个线程并发执行的技术。硬件主要体现在多核CPU，从而使CPU在同一时间处理多个线程，有效利用CPU资源，提高程序性能。
iOS多线程——GCD底层探索下（栅栏与dispatch_once与dispatch_group与dispatch_semaphore_t）
Z1591090的博客
08-04 502
栅栏函数的拓展和底层源码分析 栅栏函数基础 栅栏函数栏队列 - (void)demo2 { dispatch_queue_t queue2 = dispatch_queue_create("queue2", DISPATCH_QUEUE_CONCURRENT); dispatch_async(queue2, ^{ sleep(2); NSLog(@"异步任务"); }); dispatch_barrier_asyn
iOS开发基础教程：从入门到精通
15. **Chapter 15: GrandCentralDispatch,BackgroundProcessing,andYou** - 讲解GCD（Grand Central Dispatch）和后台处理，如何在iOS中有效地进行多线程编程和任务调度。 16. **Chapter 16: ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值