GCD 串行/并行、同步/异步 组合

最新推荐文章于 2023-11-18 18:52:48 发布
最新推荐文章于 2023-11-18 18:52:48 发布
阅读量395 收藏
点赞数
分类专栏： ios
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iOSZZZh/article/details/103652974
版权

串行/并行：决定怎么拿任务，串行 - 一个任务完成再拿下一个，并行 - 同时拿多个。

同步/异步：决定怎么取线程，同步 - 不开新线程，异步：具备开多条线程能力

 

同步、串行：一个一个执行，不开线程。

同步、并行：一个一个执行，不开线程。

异步、串行：一个一个执行，开一条线程。

异步、并行：多个同时执行，开多条线程。

- (void)viewDidLoad {
    [super viewDidLoad];

    NSLog(@"============ mainThread %@",[NSThread mainThread]);
    
    [self cx_tb];
}

// 串行 + 同步
- (void)cx_tb
{
    dispatch_queue_t cx = dispatch_queue_create("ser", DISPATCH_QUEUE_SERIAL);
    for(int i = 0; i < 10; i++)
    {
        dispatch_sync(cx, ^{
            NSLog(@"--- %d, %@",i, [NSThread currentThread]);
            sleep(0.3);
            NSLog(@"--- 结束 %d",i);
        });
    }
}

// 打印结果 =================================
2019-12-22 15:31:03.441953+0800 GCD_Test[1213:1206317] ============ mainThread <NSThread: 0x600001715800>{number = 1, name = main}
2019-12-22 15:31:03.441999+0800 GCD_Test[1213:1206317] --- 0, <NSThread: 0x600001715800>{number = 1, name = main}
2019-12-22 15:31:03.442026+0800 GCD_Test[1213:1206317] --- 结束 0
2019-12-22 15:31:03.442040+0800 GCD_Test[1213:1206317] --- 1, <NSThread: 0x600001715800>{number = 1, name = main}
2019-12-22 15:31:03.442054+0800 GCD_Test[1213:1206317] --- 结束 1
2019-12-22 15:31:03.442063+0800 GCD_Test[1213:1206317] --- 2, <NSThread: 0x600001715800>{number = 1, name = main}
2019-12-22 15:31:03.442073+0800 GCD_Test[1213:1206317] --- 结束 2
2019-12-22 15:31:03.442082+0800 GCD_Test[1213:1206317] --- 3, <NSThread: 0x600001715800>{number = 1, name = main}
2019-12-22 15:31:03.442091+0800 GCD_Test[1213:1206317] --- 结束 3
2019-12-22 15:31:03.442100+0800 GCD_Test[1213:1206317] --- 4, <NSThread: 0x600001715800>{number = 1, name = main}
2019-12-22 15:31:03.442109+0800 GCD_Test[1213:1206317] --- 结束 4
2019-12-22 15:31:03.442118+0800 GCD_Test[1213:1206317] --- 5, <NSThread: 0x600001715800>{number = 1, name = main}
2019-12-22 15:31:03.442127+0800 GCD_Test[1213:1206317] --- 结束 5
2019-12-22 15:31:03.442135+0800 GCD_Test[1213:1206317] --- 6, <NSThread: 0x600001715800>{number = 1, name = main}
2019-12-22 15:31:03.442298+0800 GCD_Test[1213:1206317] --- 结束 6
2019-12-22 15:31:03.442317+0800 GCD_Test[1213:1206317] --- 7, <NSThread: 0x600001715800>{number = 1, name = main}
2019-12-22 15:31:03.442330+0800 GCD_Test[1213:1206317] --- 结束 7
2019-12-22 15:31:03.442340+0800 GCD_Test[1213:1206317] --- 8, <NSThread: 0x600001715800>{number = 1, name = main}
2019-12-22 15:31:03.442350+0800 GCD_Test[1213:1206317] --- 结束 8
2019-12-22 15:31:03.442359+0800 GCD_Test[1213:1206317] --- 9, <NSThread: 0x600001715800>{number = 1, name = main}
2019-12-22 15:31:03.442368+0800 GCD_Test[1213:1206317] --- 结束 9

 

 

//串行+异步
- (void)cx_yb
{
    dispatch_queue_t cx = dispatch_queue_create("ser", DISPATCH_QUEUE_SERIAL);
    for(int i = 0; i < 10; i++)
    {
        dispatch_async(cx, ^{
            NSLog(@"--- %d, %@",i, [NSThread currentThread]);
            sleep(0.3);
            NSLog(@"--- 结束 %d",i);
        });
    }
}


// 打印结果 =================================
2019-12-22 15:32:19.582160+0800 GCD_Test[1225:1207319] ============ mainThread <NSThread: 0x60000170d840>{number = 1, name = main}
2019-12-22 15:32:19.582329+0800 GCD_Test[1225:1207354] --- 0, <NSThread: 0x600001770d00>{number = 2, name = (null)}
2019-12-22 15:32:19.582386+0800 GCD_Test[1225:1207354] --- 结束 0
2019-12-22 15:32:19.582449+0800 GCD_Test[1225:1207354] --- 1, <NSThread: 0x600001770d00>{number = 2, name = (null)}
2019-12-22 15:32:19.582472+0800 GCD_Test[1225:1207354] --- 结束 1
2019-12-22 15:32:19.582486+0800 GCD_Test[1225:1207354] --- 2, <NSThread: 0x600001770d00>{number = 2, name = (null)}
2019-12-22 15:32:19.582498+0800 GCD_Test[1225:1207354] --- 结束 2
2019-12-22 15:32:19.582509+0800 GCD_Test[1225:1207354] --- 3, <NSThread: 0x600001770d00>{number = 2, name = (null)}
2019-12-22 15:32:19.582521+0800 GCD_Test[1225:1207354] --- 结束 3
2019-12-22 15:32:19.582533+0800 GCD_Test[1225:1207354] --- 4, <NSThread: 0x600001770d00>{number = 2, name = (null)}
2019-12-22 15:32:19.582544+0800 GCD_Test[1225:1207354] --- 结束 4
2019-12-22 15:32:19.582554+0800 GCD_Test[1225:1207354] --- 5, <NSThread: 0x600001770d00>{number = 2, name = (null)}
2019-12-22 15:32:19.582626+0800 GCD_Test[1225:1207354] --- 结束 5
2019-12-22 15:32:19.582648+0800 GCD_Test[1225:1207354] --- 6, <NSThread: 0x600001770d00>{number = 2, name = (null)}
2019-12-22 15:32:19.582661+0800 GCD_Test[1225:1207354] --- 结束 6
2019-12-22 15:32:19.582672+0800 GCD_Test[1225:1207354] --- 7, <NSThread: 0x600001770d00>{number = 2, name = (null)}
2019-12-22 15:32:19.582682+0800 GCD_Test[1225:1207354] --- 结束 7
2019-12-22 15:32:19.582692+0800 GCD_Test[1225:1207354] --- 8, <NSThread: 0x600001770d00>{number = 2, name = (null)}
2019-12-22 15:32:19.582701+0800 GCD_Test[1225:1207354] --- 结束 8
2019-12-22 15:32:19.582711+0800 GCD_Test[1225:1207354] --- 9, <NSThread: 0x600001770d00>{number = 2, name = (null)}
2019-12-22 15:32:19.582721+0800 GCD_Test[1225:1207354] --- 结束 9

 

//并行+同步
- (void)bx_tb
{
    dispatch_queue_t bx = dispatch_queue_create("ser", DISPATCH_QUEUE_CONCURRENT);
    for(int i = 0; i < 10; i++)
    {
        dispatch_sync(bx, ^{
            NSLog(@"--- %d, %@",i, [NSThread currentThread]);
            sleep(0.3);
            NSLog(@"--- 结束 %d",i);
        });
    }
}

// 打印结果 =================================
2019-12-22 15:33:12.193521+0800 GCD_Test[1233:1208168] ============ mainThread <NSThread: 0x60000170d800>{number = 1, name = main}
2019-12-22 15:33:12.193570+0800 GCD_Test[1233:1208168] --- 0, <NSThread: 0x60000170d800>{number = 1, name = main}
2019-12-22 15:33:12.193596+0800 GCD_Test[1233:1208168] --- 结束 0
2019-12-22 15:33:12.193608+0800 GCD_Test[1233:1208168] --- 1, <NSThread: 0x60000170d800>{number = 1, name = main}
2019-12-22 15:33:12.193620+0800 GCD_Test[1233:1208168] --- 结束 1
2019-12-22 15:33:12.193629+0800 GCD_Test[1233:1208168] --- 2, <NSThread: 0x60000170d800>{number = 1, name = main}
2019-12-22 15:33:12.193639+0800 GCD_Test[1233:1208168] --- 结束 2
2019-12-22 15:33:12.193648+0800 GCD_Test[1233:1208168] --- 3, <NSThread: 0x60000170d800>{number = 1, name = main}
2019-12-22 15:33:12.193658+0800 GCD_Test[1233:1208168] --- 结束 3
2019-12-22 15:33:12.193666+0800 GCD_Test[1233:1208168] --- 4, <NSThread: 0x60000170d800>{number = 1, name = main}
2019-12-22 15:33:12.193676+0800 GCD_Test[1233:1208168] --- 结束 4
2019-12-22 15:33:12.193685+0800 GCD_Test[1233:1208168] --- 5, <NSThread: 0x60000170d800>{number = 1, name = main}
2019-12-22 15:33:12.193694+0800 GCD_Test[1233:1208168] --- 结束 5
2019-12-22 15:33:12.193821+0800 GCD_Test[1233:1208168] --- 6, <NSThread: 0x60000170d800>{number = 1, name = main}
2019-12-22 15:33:12.193841+0800 GCD_Test[1233:1208168] --- 结束 6
2019-12-22 15:33:12.193853+0800 GCD_Test[1233:1208168] --- 7, <NSThread: 0x60000170d800>{number = 1, name = main}
2019-12-22 15:33:12.193864+0800 GCD_Test[1233:1208168] --- 结束 7
2019-12-22 15:33:12.193873+0800 GCD_Test[1233:1208168] --- 8, <NSThread: 0x60000170d800>{number = 1, name = main}
2019-12-22 15:33:12.193882+0800 GCD_Test[1233:1208168] --- 结束 8
2019-12-22 15:33:12.193891+0800 GCD_Test[1233:1208168] --- 9, <NSThread: 0x60000170d800>{number = 1, name = main}
2019-12-22 15:33:12.193901+0800 GCD_Test[1233:1208168] --- 结束 9

 

//并行+异步
- (void)bx_yb
{
    dispatch_queue_t bx = dispatch_queue_create("ser", DISPATCH_QUEUE_CONCURRENT);
    for(int i = 0; i < 10; i++)
    {
        dispatch_async(bx, ^{
            NSLog(@"--- %d, %@",i, [NSThread currentThread]);
            sleep(0.3);
            NSLog(@"--- 结束 %d",i);
        });
    }
}

// 打印结果 =================================
2019-12-22 15:34:00.432239+0800 GCD_Test[1243:1208883] ============ mainThread <NSThread: 0x600001709840>{number = 1, name = main}
2019-12-22 15:34:00.432573+0800 GCD_Test[1243:1208928] --- 0, <NSThread: 0x600001746dc0>{number = 3, name = (null)}
2019-12-22 15:34:00.432581+0800 GCD_Test[1243:1208933] --- 1, <NSThread: 0x60000170dd80>{number = 2, name = (null)}
2019-12-22 15:34:00.432581+0800 GCD_Test[1243:1208932] --- 2, <NSThread: 0x600001752980>{number = 4, name = (null)}
2019-12-22 15:34:00.432649+0800 GCD_Test[1243:1208929] --- 3, <NSThread: 0x600001770040>{number = 5, name = (null)}
2019-12-22 15:34:00.432666+0800 GCD_Test[1243:1208961] --- 6, <NSThread: 0x60000176b0c0>{number = 8, name = (null)}
2019-12-22 15:34:00.432671+0800 GCD_Test[1243:1208960] --- 5, <NSThread: 0x6000017076c0>{number = 7, name = (null)}
2019-12-22 15:34:00.432676+0800 GCD_Test[1243:1208933] --- 结束 1
2019-12-22 15:34:00.432682+0800 GCD_Test[1243:1208932] --- 结束 2
2019-12-22 15:34:00.432682+0800 GCD_Test[1243:1208929] --- 结束 3
2019-12-22 15:34:00.432686+0800 GCD_Test[1243:1208961] --- 结束 6
2019-12-22 15:34:00.432681+0800 GCD_Test[1243:1208962] -2019-12-22 15:34:00.432685+0800 GCD_Test[1243:1208928] --- 结束 0
-- 7, <NSThread: 0x600001752b00>{number = 9, name = (null)}
2019-12-22 15:34:00.432688+0800 GCD_Test[1243:1208963] --- 8, <NSThread: 0x600001745240>{number = 10, name = (null)}
2019-12-22 15:34:00.432675+0800 GCD_Test[1243:1208959] --- 4, <NSThread: 0x600001770080>{number = 6, name = (null)}
2019-12-22 15:34:00.432770+0800 GCD_Test[1243:1208959] --- 结束 4
2019-12-22 15:34:00.432772+0800 GCD_Test[1243:1208963] --- 结束 8
2019-12-22 15:34:00.432775+0800 GCD_Test[1243:1208962] --- 结束 7
2019-12-22 15:34:00.432697+0800 GCD_Test[1243:1208960] --- 结束 5
2019-12-22 15:34:00.432714+0800 GCD_Test[1243:1208964] --- 9, <NSThread: 0x600001764040>{number = 11, name = (null)}
2019-12-22 15:34:00.432816+0800 GCD_Test[1243:1208964] --- 结束 9

 

 

攻城狮Corn
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解IOS串行队列与并行队列进行同步或者异步的实例
01-21
IOS中GCD的队列分为串行队列和并行队列，任务分为同步任务和异步任务，他们的排列组合有四种情况，下面分析这四种情况的工作方式。 同步任务，使用GCD dispatch_sync 进行派发任务 - (void)testSync { dispatch_...
GCD编程中串行、并行、同步、异步的执行顺序
feisongfeiqin的博客
12-13 5722
串行队列、并行队列、同步、异步是gcd编程中四个非常重要的概念，它们的组合会产生多种不同的执行顺序，在本文，我主要通过代码来罗列一下所有的可能产生的结果，并根据执行结果总结一下gcd编程的一些特点。
GCD：异步同步？串行并发？一文轻松拿捏！
最新发布
yueliangmua的博客
11-18 219
同步、异步、串行、并发、同步并发、同步串行、异步并发、异步串行、任务组、信号量。。。。。。
多线程——GCD(串行队列)
热门推荐
iOS开发
11-21 1万+
无论队列中所指定的执行的函数是同步还是异步，都会等待前一个任务执行完成后，再调度后面的任务 要不要开线程由执行任务决定 dispatch_sync 不开 dispatch_async 开 开几条线程由谁决定 串行队列，异步执行，开几条，由底层线程池决定 串行队列，同步执行，不开线程 串行队列，异步执行任务 - (void)gcdDemo1 { for (NSInteger index =
GCD总结（一）
weixin_30429201的博客
05-14 104
　GCD为我们提供了三种类型的调度队列（dispatch queue），分别为串行，并行和主调度队列。 串行（Serial） 你可以创建任意个数的串行队列，每个队列依次执行添加的任务，一个队列同一时刻只能执行一个任务（串行），但是各个队列之间不影响，可以并发执行。每个队列中的任务运行在一个由各自串行队列维护的独立线程上，一个队列中只有一个线程。 　　下面，我将创建一个串...
ios多线程操作（五）—— GCD串行队列与并发队列
爱家人，爱老婆，爱生活，爱coding，爱运动的有爱青年
03-19 9968
GCD的队列可以分为2大类型，分别为串行队列和并发队列      串行队列（Serial Dispatch Queue）：      一次只调度一个任务，队列中的任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）      创建一个队列      dispatch_queue_t q = dispatch_queue_create(const char *label, disp
GCD --简单（穿并行的同步异步）Demo
06-21
关于GCD的简单的 方法（串行同步，串行异步；并行同步，并行异步）
OC-GCD异步线程下载图片
08-02
OC-GCD异步线程下载图片
iOS-GCD详解及简单使用
01-21
对初学者来说，GCD似乎是一道迈不过去的坎，很多人在同步、异步、串行、并行和死锁这几个名词的漩涡中渐渐放弃治疗。本文将使用图文表并茂的方式给大家形象地解释其中的原理和规律。 线程、任务和队列的概念 异步、...
iOS进阶_GCD(二.GCD串行队列&并发队列）
十二指环的博客
05-04 3005
GCD 核心概念：将任务添加到队列，指定任务执行的方法 任务 使用block封装 block 就是一个提前准备好的代码块，在需要的时候执行 队列（负责调度任务） 串行队列：一个接一个的调度任务 并发队列：可以同时调度多个任务 任务执行函数（任务都需要在线程中执行！） 同步执行：当前指令不完成，不会执行下个指令 异步执行：当前指令不完成，同样可以执行下一条指令 总结： -开不开线...
iOS 多线程--GCD 串行队列、并发队列以及同步执行、异步执行
u013712343的博客
06-24 2154
1 什么是队列（queue） 在开始GCD之前先来说一下队列的概念，因为GCD的任务都是在队列中派发的； 队列（queue）：是先进先出（FIFO, First-In-First-Out）的线性表。但是在队列前面加上串行和并发这两个定语之后，也就是串行队列、并发队列，有时就容易搞不清楚了，特别是再加上同步和异步的概念之后，有时就更不清楚了。 2 串行队列和并发队列 注意是并发队列（Concurrent Queue），不是并行队列，关于并发和并行的区别见下一节 什么是串行队列和并发队列呢？上面已经说.
GCD中的并行队列和串行队列
howl_MK的博客
03-18 665
#pragma mark -并行队列- (void)gcdDemo2{   // 1.并行队列   dispatch_queue_tq =dispatch_queue_create("myQueue",DISPATCH_QUEUE_CONCURRENT);      //非ARC中，需要自己释放队列//    dispatch_release(q);      // 3.同步任务，不会开启新的线程...
串行队列
shuiyue184480的博客
03-13 511
NSLog(@"1"); dispatch_sync(dispatch_get_global_queue(0, 0), ^{ NSLog(@"2"); }); NSLog(@"3"); 运行后正常输出，1，2，3 NSLog(@"1"); dispatch_sync(dispatch_get_main_queue(), ^{ ...
GCD 队列串行 并行 同步 异步 小例
星宇大前端
05-31 529
发现GCD Swift版有所更改，以后小例都用swift写，练习熟悉。 坚持，每天收获一点。 // //  ViewController.swift //  GCD_demo // //  Created by apple on 2017/5/31. //  Copyright © 2017年 ZY. All rights reserved.
iOS开发中的并发、串行队列，同步、异步任务
梁森的博客
04-09 7215
在多线程开发中我们经常会遇到这些概念：并发队列、串行队列、同步任务、异步任务。我们将这四个概念进行组合会有四种结果：串行队列＋同步任务、串行队列＋异步任务、并发队列＋同步任务、并发队列＋异步任务。我们对这四种结果进行解释： 1.串行队列＋同步任务：不会开启新的线程，任务逐步完成。 2.串行队列＋异步任务：开启新的线程，任务逐步完成。 3.并发队列＋同步任务：不会开启新的线程，任务逐步完成。
iOS-GCD的串行队列和并行队列的任务及实现
CuiAnkly的博客
04-17 1万+
什么是GCD GCD全称是GrandCentral Dispatch,纯C语言的，提供了非常多强大的函数 •GCD的优势 1,GCD是苹果公司为多核的并行运算提出的解决方案 2,GCD会自动利用更多的CPU内核（比如双核、四核） 3,GCD会自动管理线程的生命周期（创建线程、调度任务、销毁线程） 4,程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码
ios-day19-02(GCD介绍。串行队列、并行队列、全局队列、主队列、同步任务、异步任务)
liu537192的专栏
04-03 3580
// // JLViewController.m // 01-GCD // // Created by XinYou on 15-4-3. // Copyright (c) 2015年 vxinyou. All rights reserved. // #import "JLViewController.h" @interface JLViewController (
iOS GCD：队列、锁、安全解决方案
qq_27909209的博客
09-27 2531
1：iOS中的常见多线程方案 2：GCD的常用函数 3：GCD的队列 4：死锁问题 5：问题 5.1：问题1： 5.2：问题2： 5.3：问题3： 6：多线程的安全隐患 7：（安全问题）解决方案 7.1：iOS中的线程同步方案 7.2：iOS线程同步方案性能比较 7.3：atomic ...
iOS 之GCD串行和并发队列的理解
weixin_34381666的博客
08-13 95
dispatch_queue_t serialQueue = dispatch_queue_create("com.lai.www", DISPATCH_QUEUE_SERIAL); dispatch_async(serialQueue, ^{ // NSLog(@"1"); sleep(3); NSLog(@"1");...
for (ll gcd : {i, diff / i})
07-12
这段代码看起来是使用了...在循环中，`gcd` 是一个循环变量，它依次取列表中的每个元素。这样，循环体内的代码会针对每个 `gcd` 值执行一次。 需要注意的是，代码中的 `diff / i` 可能是计算 `diff` 除以 `i` 的结果。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值