OC下的串行、并行和同步、异步的组合

已于 2022-06-16 18:01:16 修改
阅读量869 收藏
点赞数
分类专栏： objective-c ios 多线程 文章标签： GCD 线程同步 异步任务 串行队列 并行队列
于 2022-06-16 17:40:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36924305/article/details/125318863
版权
objective-c 同时被 3 个专栏收录
18 篇文章 0 订阅
订阅专栏
ios
16 篇文章 0 订阅
订阅专栏
多线程
1 篇文章 0 订阅
订阅专栏

串行：类似买东西只排了一个队伍，按顺序执行，不分同步异步，先进先出

串行+纯同步：

    //创建串行队列，并设置队列名
    static const char* queName = "name";
    dispatch_queue_t que = dispatch_queue_create(queName, DISPATCH_QUEUE_SERIAL);
    dispatch_queue_set_specific(que, queName, &queName, nil);
    if (dispatch_get_specific(queName)) {
        NSLog(@"1111");
    }else{
        dispatch_sync(que, ^{
            
            sleep(2);
            NSLog(@"222222");
        });
    }
    if (dispatch_get_specific(queName)) {
        NSLog(@"3333");
    }else{
        dispatch_sync(que, ^{
            sleep(2);
            NSLog(@"44444");
        });
    }
    if (dispatch_get_specific(queName)) {
        NSLog(@"55555");
    }else{
        dispatch_sync(que, ^{
            
            sleep(2);
            NSLog(@"666666");
        });
    }
    NSLog(@"777777");

立即阻塞当前线程，执行队列任务，等待全部任务完成后返回原线程。

运行结果如下：

2022-06-16 16:46:51.081025+0800 test[1409:577908] 222222

2022-06-16 16:46:53.082349+0800 test[1409:577908] 44444

2022-06-16 16:46:55.083660+0800 test[1409:577908] 666666

2022-06-16 16:46:55.083903+0800 test[1409:577908] 777777

同步+纯异步：

    
    //创建串行队列，并设置队列名
    static const char* queName = "name";
    dispatch_queue_t que = dispatch_queue_create(queName, DISPATCH_QUEUE_SERIAL);
    dispatch_queue_set_specific(que, queName, &queName, nil);
    if (dispatch_get_specific(queName)) {
        NSLog(@"1111");
    }else{
        dispatch_async(que, ^{
            
            sleep(2);
            NSLog(@"222222");
        });
    }
    if (dispatch_get_specific(queName)) {
        NSLog(@"3333");
    }else{
        dispatch_async(que, ^{
            sleep(2);
            NSLog(@"44444");
        });
    }
    if (dispatch_get_specific(queName)) {
        NSLog(@"55555");
    }else{
        dispatch_async(que, ^{
            
            sleep(2);
            NSLog(@"666666");
        });
    }
    NSLog(@"777777");

不阻塞当前线程。开辟一个新的线程顺序执行队列任务

运行结果如下：

2022-06-16 16:52:37.516960+0800 test[1412:579327] 777777

2022-06-16 16:52:39.522169+0800 test[1412:579341] 222222

2022-06-16 16:52:41.525529+0800 test[1412:579341] 44444

2022-06-16 16:52:43.530921+0800 test[1412:579341] 666666

同步＋异步同步混合：


    //创建串行队列，并设置队列名
    static const char* queName = "name";
    dispatch_queue_t que = dispatch_queue_create(queName, DISPATCH_QUEUE_SERIAL);
    dispatch_queue_set_specific(que, queName, &queName, nil);
    if (dispatch_get_specific(queName)) {
        NSLog(@"1111");
    }else{
        dispatch_async(que, ^{
            
            sleep(2);
            NSLog(@"222222");
        });
    }
    if (dispatch_get_specific(queName)) {
        NSLog(@"3333");
    }else{
        dispatch_sync(que, ^{
            sleep(2);
            NSLog(@"44444");
        });
    }
    if (dispatch_get_specific(queName)) {
        NSLog(@"55555");
    }else{
        dispatch_async(que, ^{
            
            sleep(2);
            NSLog(@"666666");
        });
    }
    
    if (dispatch_get_specific(queName)) {
        NSLog(@"8888");
    }else{
        dispatch_sync(que, ^{
            
            sleep(2);
            NSLog(@"99999");
        });
    }
    if (dispatch_get_specific(queName)) {
        NSLog(@"aaaaaa");
    }else{
        dispatch_async(que, ^{
            
            sleep(2);
            NSLog(@"bbbbbbb");
        });
    }
    NSLog(@"777777");

立即阻塞当前任务，当队列中最后一个同步执行结束后，立即返回当前任务（即使后面还有异步任务需要执行也会返回）,队列中的任务一定是按顺序运行的，不区分同步异步

运行结果如下：

2022-06-16 16:57:05.541766+0800 test[1421:581767] 222222

2022-06-16 16:57:07.543157+0800 test[1421:581748] 44444

2022-06-16 16:57:09.544609+0800 test[1421:581767] 666666

2022-06-16 16:57:11.545975+0800 test[1421:581748] 99999

2022-06-16 16:57:11.546284+0800 test[1421:581748] 777777

2022-06-16 16:57:13.551024+0800 test[1421:581767] bbbbbbb

并行：先进先出。类似买东西排队，一个队伍，但最前面的顾客如果是异步的，则立即换一个新地方买（开辟新线程），后续顾客立即向前移动一个。同步的顾客则停在当前队伍购买，后面的顾客需要等待该顾客完成（即使后面有异步顾客，异步顾客也得等该同步顾客完成才能运行）。

并行+纯同步：

    //创建串行队列，并设置队列名
    static const char* queName = "name";
    dispatch_queue_t que = dispatch_queue_create(queName, DISPATCH_QUEUE_CONCURRENT);
    dispatch_queue_set_specific(que, queName, &queName, nil);
    if (dispatch_get_specific(queName)) {
        NSLog(@"1111");
    }else{
        dispatch_sync(que, ^{
            
            sleep(2);
            NSLog(@"222222");
        });
    }
    if (dispatch_get_specific(queName)) {
        NSLog(@"3333");
    }else{
        dispatch_sync(que, ^{
            sleep(2);
            NSLog(@"44444");
        });
    }
    if (dispatch_get_specific(queName)) {
        NSLog(@"55555");
    }else{
        dispatch_sync(que, ^{
            
            sleep(2);
            NSLog(@"666666");
        });
    }
    
    NSLog(@"777777");

立即阻塞当前任务，执行队列任务，队列任务完成后返回当前任务

执行结果：

2022-06-16 17:03:37.613182+0800 test[1427:583818] 222222

2022-06-16 17:03:39.614572+0800 test[1427:583818] 44444

2022-06-16 17:03:41.615903+0800 test[1427:583818] 666666

2022-06-16 17:03:41.616188+0800 test[1427:583818] 777777

并行+纯异步：

 //创建串行队列，并设置队列名
    static const char* queName = "name";
    dispatch_queue_t que = dispatch_queue_create(queName, DISPATCH_QUEUE_CONCURRENT);
    dispatch_queue_set_specific(que, queName, &queName, nil);
    if (dispatch_get_specific(queName)) {
        NSLog(@"1111");
    }else{
        dispatch_async(que, ^{
            
            sleep(2);
            NSLog(@"222222");
        });
    }
    if (dispatch_get_specific(queName)) {
        NSLog(@"3333");
    }else{
        dispatch_async(que, ^{
            sleep(2);
            NSLog(@"44444");
        });
    }
    if (dispatch_get_specific(queName)) {
        NSLog(@"55555");
    }else{
        dispatch_async(que, ^{
            
            sleep(2);
            NSLog(@"666666");
        });
    }
    
    NSLog(@"777777");

不影响当前任务，有多少个异步就开辟多少线程。线程完成顺序未知。

运行结果：

2022-06-16 17:09:02.320619+0800 test[1432:585400] 777777

2022-06-16 17:09:04.322568+0800 test[1432:585412] 222222

2022-06-16 17:09:04.325889+0800 test[1432:585414] 44444

2022-06-16 17:09:04.325892+0800 test[1432:585413] 666666

并行+同步异步混合：

    //创建串行队列，并设置队列名
    static const char* queName = "name";
    dispatch_queue_t que = dispatch_queue_create(queName, DISPATCH_QUEUE_CONCURRENT);
    dispatch_queue_set_specific(que, queName, &queName, nil);
    if (dispatch_get_specific(queName)) {
        NSLog(@"1111");
    }else{
        dispatch_async(que, ^{
            
            sleep(2);
            NSLog(@"222222");
        });
    }
    if (dispatch_get_specific(queName)) {
        NSLog(@"3333");
    }else{
        dispatch_sync(que, ^{
            sleep(2);
            NSLog(@"44444");
        });
    }
    if (dispatch_get_specific(queName)) {
        NSLog(@"55555");
    }else{
        dispatch_async(que, ^{
            
            sleep(2);
            NSLog(@"666666");
        });
    }
    if (dispatch_get_specific(queName)) {
        NSLog(@"88888");
    }else{
        dispatch_sync(que, ^{
            sleep(2);
            NSLog(@"999999");
        });
    }
    if (dispatch_get_specific(queName)) {
        NSLog(@"aaaaa");
    }else{
        dispatch_async(que, ^{
            
            sleep(2);
            NSLog(@"bbbbbb");
        });
    }
    NSLog(@"777777");

立即阻塞当前任务，队列最前方如果是异步，则开辟新线程，异步立即出队列（即使异步任务没完成）。如果最前方是同步队列，则同步任务完成后出队列，后续任务都需要等待（无论同步异步），同步任务一定是按入栈顺序运行，异步任务完成则是未知的。最后一个同步任务完成后立即返回当前任务（即使还有异步）。

运行结果如下：

2022-06-16 17:26:16.375671+0800 test[1450:591469] 44444

2022-06-16 17:26:16.379838+0800 test[1450:591482] 222222

2022-06-16 17:26:18.377038+0800 test[1450:591469] 999999

2022-06-16 17:26:18.377093+0800 test[1450:591480] 666666

2022-06-16 17:26:18.377342+0800 test[1450:591469] 777777

2022-06-16 17:26:20.379147+0800 test[1450:591480] bbbbbb

Dream_Dynasty
关注
专栏目录
OC底层探索(二十一)GCD异步、GCD同步、单例、信号量、调度组、栅栏函数等底层分析
正在注销账号的博客
11-07 1087
OC底层文章汇总 在上一篇OC底层探索(十九) 多线程文章中介绍了OC中GCD的使用，那么GCD的底层原理是什么呢？ 1、单例源码 1.1 前期准备 新建一个GCD单例 在这里插入代码片 1.2 源码分析 查看dispatch_once,发现dispatch_once_f函数 在这里插入代码片 ???? 查看dispatch_once_f，参数分别为 在这里插入代码片 ???? ???? ???? ???? 2、异步线程 3、GCD 函数的调用 3.1 前期准备 写一个GCD线程，在函
GCD简析（同步、异步、串行、并行）
飞落的眼泪的专栏
09-06 575
/* * *需求规定：四个耗时任务A、B、C、D，要求先执行A，A执行完毕后才能开始B和C，但是B和C没有先后顺序，即并发执行，但是必须B和C都结束以后才能执行D。 *因为四个任务都是耗时任务，所以必须放入子线程中才行，否则会导致线程阻塞，又B和C并发执行，所以B和C是异步并发执行的任务。下面是具体代码。 *///对任务A创建一个SERIAL队列，即同
oc中的串行、并行与同步、异步
dream328的专栏
12-02 1446
oc中的串行、并行与同步、异步 oc中向队列中添加任务有两种方式：同步和异步 而队列中任务的执行方式有两种：串行和并行 同步方式指的是添加任务后阻塞当前线程直到任务被加入队列并且执行结束 异步方式指的是加入任务队列后，不必等待任务执行，函数立即返回
OC学习总结之异步连接
u013302606的专栏
04-14 389
哎, 前几天去了趟韩国, 浪了几天.  一直没机会写博客. 这不回来的第一天上班就是儿童节,祝大家节日快乐哈..不吹牛逼了   直接搞起 1、同步连接和异步连接 同步连接是iOS中网络连接的一种方式，当请求的数据量小时，同步连接是一个很好的选择。UI“冻结”是它的一个缺点。 同步连接步骤： //新建一个URL     NSURL *url = [NSURL URLWithStrin
iOS oc 线程 进程，同步异步，并发串行，来捋捋
weixin_34117211的博客
02-20 201
2019独角兽企业重金招聘Python工程师标准>>> ...
Objective-C 异步任务
JerryChen的专栏
11-27 7064
Objective-C提供了多种不同的异步处理方式，这里主要看3种比较常用的方式：NSThread、Grand Central Dispatch与NSOperationQueue。 一、NSThread NSThread是OC提供的线程类，基于此，我们可以很方便地开辟线程。在OS X V10.5之前，该类只提供了一种开启新线程的方法(如:[NSThread detachNewThrea
OC-串行队列在异步线程中执行
06-03
在多线程编程中，理解和利用串行队列在异步线程中的执行是至关重要的，它可以帮助我们优化应用性能，提高用户体验。本文将深入探讨OC中的串行队列以及它们在异步线程中的工作原理。 首先，我们要理解什么是线程。在...
OC中串行队列与同步线程的执行机制探究
资源摘要信息: "OC- 串行队列在同步线程中执行" 在Objective-C编程语言中，串行队列是一种...务必注意使用场景和潜在风险，如死锁问题，合理地在并行与串行、同步与异步之间做出权衡，以提高应用程序的性能和稳定性。
oc 同步、异步图片下载
weixin_38401994的博客
09-22 417
同步加载：     NSURL*url=[NSURL URLWithString:s.user.profileImageUrl];          NSData*data=[NSData dataWithContentsOfURL:url];          cell.imageView.image=[UIImage imageWithData:data
OC-并发队列在异步线程中执行
最新发布
06-03
在iOS和Mac开发中，Objective-C（简称OC）是主要的编程语言，它在Apple的Cocoa Touch和Cocoa框架中扮演着核心角色。当我们谈论“OC-并发队列在异步线程中执行”时，我们实际上是在讨论多线程编程中的一个关键概念...
IOS开发中异步网络请求上实现同步逻辑
01-06
IOS开发中异步网络请求上实现同步逻辑 前提： 可能遇到一些问题，比如上传多个数据，需要等多个数据上传成功后做一定的处理，而且一个个上传，万一哪个上传失败了，后面就不需要上传了，直接报错。 之前ASI的网络库中是有同步请求的接口，所以很好处理，AFNetwork的网络库只有异步的网络请求，该怎么实现呢？ 1.循环异步拼组 - (void)uploadFile:(NSArray *)imageArray atIndex:(NSInteger)index imagesCount:(NSInteger)count completeBlock:(uploadCompleteBlock)block {
OC 线程操作 - GCD使用 -同步函数，异步函数，串行队列，并发队列
weixin_30691871的博客
06-26 383
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{ // GCD 开几条线程并不是我们可以控制的，而是系统来决定的， // [self asyncConcurrent]; // [self asyncSerial]; // ...
OC 异步顺序加载的方法
weixin_30666753的博客
01-02 183
方法一：发射信号量 OC —异步顺序加载 先调用A接口，再调用B接口，再调用C接口 dispatch_semaphore_t semaphore = dispatch_semaphore_create(0); 网络A请求 中间写block块的网络请求 dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER); d...
OC学习心得之异步连接
pq1051288217的博客
11-15 365
 1、同步连接和异步连接 同步连接是iOS中网络连接的一种方式，当请求的数据量小时，同步连接是一个很好的选择。UI“冻结”是它的一个缺点。 同步连接步骤： //新建一个URL     NSURL *url = [NSURL URLWithString:@"http://api.hudong.com/iphonexml.do?type=focus-c"];     //创建一个请求
重学OC第二十一篇：@synchronized分析
Rain and Tears
11-07 1333
文章目录一、clang分析@synchronized二、objc_sync_enter()源码解析2.1 id2data()函数分析三、objc_sync_exit源码总结 一、clang分析@synchronized int main(int argc, const char * argv[]) { NSObject *obj = [[NSObject alloc] init]; @synchronized (obj) { } return 0; } 通过clang -re
IOS开发（62）之GCD上异步执行非UI任务
Developer_Zhang的专栏
05-10 3387
1 前言 如果想要在 GCD 的帮助下能够异步执行 Non-UI 相关任务。在主队列、串行队列和并发队列上异步执行代码块才能见识到 GCD 的真正实力。  要在分派队列上执行异步任务,你必须使用下面这些函数中的其中一个: dispatch_async 为了异步执行向分派队列提交一个 Block Object(2 个都通过函数指定); eg：
oc请求get同步
pureszgd的博客
01-14 494
oc请求get同步 #ios NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url]; [request setHTTPMethod:@“get”]; [NSURLConnection sendSynchronousRequest:request returningResponse:nil error:nil]...
[OC学习笔记]浅学GCD线程相关内容
weixin_52192405的博客
02-19 499
GCD浅学
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值