美文网首页iOS线程iOS开发之常用技术点iOS开发之常见问题
串并行和同异步之间的关系

串并行和同异步之间的关系

作者: 刀客传奇 | 来源:发表于2017-08-16 23:50 被阅读38次

版本记录

版本号 时间
V1.0 2017.08.16

前言

ios中有串行和并行、同步和异步的概念，这些概念并不难，但是仍然需要大家好好的理解，这一篇就详细的和大家说说它们之间的关系，希望对大家有所帮助。

同异步和串并行之间的关系

首先我们看一下ios中同异步和队列串并行的关系，看一张很常见和经典的图。

同异步和串并行之间的关系

这张图很好的把他们的关系全部总结出来了，剩下的就看大家的理解了。

串行和并行

我们先看一下队列的概念。

队列是先进先出（FIFO）结构的，其主要的任务主要是负责线程的创建、回收工作，不论什么队列和什么任务都不需要程序员参与，减轻了程序员的工作。

队列主要分为：

  • GCD队列
    • 运行在主线程中的主队列。
    • 3 个不同优先级的后台队列。
    • 一个优先级更低的后台队列（用于 I/O）。
  • 自定义队列
    • 串行队列
    • 并行队列。
    • 自定义队列非常强大，建议在开发中使用。在自定义队列中被调度的所有Block最终都将被放入到系统的全局队列中和线程池中。

下面看一张非常重要的图。

队列图

从图中可以看出串行队列、并行队列都属于默认优先级的GCD队列。

1. 串行

串行是一次只能执行一个任务。让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）。

2. 并行

并行是一次能执行多个任务。可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务），并发功能只有在异步函数下才有效。

同步和异步

1. 同步

所谓同步，就是在发出一个调用时，在没有得到结果之前，该调用就不返回。但是一旦调用返回，就得到返回值了。注意这个返回是指CUP返回执行的数据段部分，所以目前来看只是阻塞了CPU的数据段部分 并不耽误CPU干别的 所以即使是同步也不见得是阻塞模式

换句话说，就是由调用者主动等待这个调用的结果。

2. 异步

所谓异步，就是调用在发出之后，这个调用就直接返回了，所以没有返回结果。换句话说，当一个异步过程调用发出后，调用者不会立刻得到结果。而是在调用发出后，被调用者通过状态、通知来通知调用者，或通过回调函数处理这个调用。

几个重要例子

1. 串行队列 + 异步任务

下面直接看代码。

#import "JJQueueStatusVC.h"

@interface JJQueueStatusVC ()

@end

@implementation JJQueueStatusVC

#pragma mark - Override Base Function

- (void)viewDidLoad
{
    [super viewDidLoad];
    
    self.view.backgroundColor = [UIColor whiteColor];
    
    [self serialAndAsync];
}

#pragma mark - Object Private Function

//串行队列 + 异步任务

- (void)serialAndAsync
{
    //串行队列
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);

    for (NSInteger i = 0; i < 10; i ++) {
        //创建要执行的任务
        void(^task)() = ^{
            NSLog(@"%ld--%@",i, [NSThread currentThread]);
        };
        
        //将任务添加到队列
        dispatch_async(queue, task);
    }
}

@end

下面看输出结果

2017-08-16 22:37:20.295 JJOC[1512:40834] 0--<NSThread: 0x600000265440>{number = 3, name = (null)}
2017-08-16 22:37:20.296 JJOC[1512:40834] 1--<NSThread: 0x600000265440>{number = 3, name = (null)}
2017-08-16 22:37:20.296 JJOC[1512:40834] 2--<NSThread: 0x600000265440>{number = 3, name = (null)}
2017-08-16 22:37:20.296 JJOC[1512:40834] 3--<NSThread: 0x600000265440>{number = 3, name = (null)}
2017-08-16 22:37:20.296 JJOC[1512:40834] 4--<NSThread: 0x600000265440>{number = 3, name = (null)}
2017-08-16 22:37:20.297 JJOC[1512:40834] 5--<NSThread: 0x600000265440>{number = 3, name = (null)}
2017-08-16 22:37:20.297 JJOC[1512:40834] 6--<NSThread: 0x600000265440>{number = 3, name = (null)}
2017-08-16 22:37:20.297 JJOC[1512:40834] 7--<NSThread: 0x600000265440>{number = 3, name = (null)}
2017-08-16 22:37:20.297 JJOC[1512:40834] 8--<NSThread: 0x600000265440>{number = 3, name = (null)}
2017-08-16 22:37:20.298 JJOC[1512:40834] 9--<NSThread: 0x600000265440>{number = 3, name = (null)}

结论：由上可知

  • 开启了新的线程
  • 任务是串行执行的。

2. 串行队列 + 同步任务

下面还是直接看代码。

#import "JJQueueStatusVC.h"

@interface JJQueueStatusVC ()

@end

@implementation JJQueueStatusVC

#pragma mark - Override Base Function

- (void)viewDidLoad
{
    [super viewDidLoad];
    
    self.view.backgroundColor = [UIColor whiteColor];

    [self serialAndSync];
}

#pragma mark - Object Private Function

//串行队列 + 同步任务

- (void)serialAndSync
{
    //串行队列
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);
    
    for (NSInteger i = 0; i < 10; i ++) {
        //创建要执行的任务
        void(^task)() = ^{
            NSLog(@"%ld--%@",i, [NSThread currentThread]);
        };
        
        //将任务添加到队列
        dispatch_sync(queue, task);
    }
}

@end

下面看输出结果

2017-08-16 22:41:37.427 JJOC[1661:44282] 0--<NSThread: 0x6000000643c0>{number = 1, name = main}
2017-08-16 22:41:37.428 JJOC[1661:44282] 1--<NSThread: 0x6000000643c0>{number = 1, name = main}
2017-08-16 22:41:37.428 JJOC[1661:44282] 2--<NSThread: 0x6000000643c0>{number = 1, name = main}
2017-08-16 22:41:37.428 JJOC[1661:44282] 3--<NSThread: 0x6000000643c0>{number = 1, name = main}
2017-08-16 22:41:37.429 JJOC[1661:44282] 4--<NSThread: 0x6000000643c0>{number = 1, name = main}
2017-08-16 22:41:37.429 JJOC[1661:44282] 5--<NSThread: 0x6000000643c0>{number = 1, name = main}
2017-08-16 22:41:37.429 JJOC[1661:44282] 6--<NSThread: 0x6000000643c0>{number = 1, name = main}
2017-08-16 22:41:37.429 JJOC[1661:44282] 7--<NSThread: 0x6000000643c0>{number = 1, name = main}
2017-08-16 22:41:37.429 JJOC[1661:44282] 8--<NSThread: 0x6000000643c0>{number = 1, name = main}
2017-08-16 22:41:37.430 JJOC[1661:44282] 9--<NSThread: 0x6000000643c0>{number = 1, name = main}

结论：由上可知

  • 没有开启了新的线程，还是在主线程中执行。
  • 任务是串行执行的。

3. 并发队列 + 异步任务

还是直接看代码。

#import "JJQueueStatusVC.h"

@interface JJQueueStatusVC ()

@end

@implementation JJQueueStatusVC

#pragma mark - Override Base Function

- (void)viewDidLoad
{
    [super viewDidLoad];
    
    self.view.backgroundColor = [UIColor whiteColor];
    
    [self concurrentAndAsync];
}

#pragma mark - Object Private Function

//并发队列 + 异步任务

- (void)concurrentAndAsync
{
    //并发队列
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
    
    for (NSInteger i = 0; i < 10; i ++) {
        //创建要执行的任务
        void(^task)() = ^{
            NSLog(@"%ld--%@",i, [NSThread currentThread]);
        };
        
        //将任务添加到队列
        dispatch_async(queue, task);
    }
}

@end

下面看输出结果

2017-08-16 22:50:09.200 JJOC[1946:50520] 1--<NSThread: 0x60800006cdc0>{number = 4, name = (null)}
2017-08-16 22:50:09.200 JJOC[1946:50517] 2--<NSThread: 0x600000073c40>{number = 5, name = (null)}
2017-08-16 22:50:09.200 JJOC[1946:50518] 0--<NSThread: 0x60800006ca00>{number = 3, name = (null)}
2017-08-16 22:50:09.200 JJOC[1946:50539] 3--<NSThread: 0x600000073d40>{number = 6, name = (null)}
2017-08-16 22:50:09.200 JJOC[1946:50540] 4--<NSThread: 0x600000073c80>{number = 7, name = (null)}
2017-08-16 22:50:09.200 JJOC[1946:50520] 5--<NSThread: 0x60800006cdc0>{number = 4, name = (null)}
2017-08-16 22:50:09.200 JJOC[1946:50517] 6--<NSThread: 0x600000073c40>{number = 5, name = (null)}
2017-08-16 22:50:09.200 JJOC[1946:50518] 7--<NSThread: 0x60800006ca00>{number = 3, name = (null)}
2017-08-16 22:50:09.201 JJOC[1946:50541] 8--<NSThread: 0x600000073880>{number = 8, name = (null)}
2017-08-16 22:50:09.201 JJOC[1946:50539] 9--<NSThread: 0x600000073d40>{number = 6, name = (null)}

结论：由上可知

  • 开启了新的线程。
  • 任务是并发执行的。

4. 并发队列 + 同步任务

下面看代码。

#import "JJQueueStatusVC.h"

@interface JJQueueStatusVC ()

@end

@implementation JJQueueStatusVC

#pragma mark - Override Base Function

- (void)viewDidLoad
{
    [super viewDidLoad];
    
    self.view.backgroundColor = [UIColor whiteColor];
    
    [self concurrentAndSync];
}

#pragma mark - Object Private Function

//并发队列 + 同步任务

- (void)concurrentAndSync
{
    //并发队列
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
    
    for (NSInteger i = 0; i < 10; i ++) {
        //创建要执行的任务
        void(^task)() = ^{
            NSLog(@"%ld--%@",i, [NSThread currentThread]);
        };
        
        //将任务添加到队列
        dispatch_sync(queue, task);
    }
}

@end

下面看输出结果

2017-08-16 22:57:16.705 JJOC[2271:56082] 0--<NSThread: 0x608000068540>{number = 1, name = main}
2017-08-16 22:57:16.706 JJOC[2271:56082] 1--<NSThread: 0x608000068540>{number = 1, name = main}
2017-08-16 22:57:16.706 JJOC[2271:56082] 2--<NSThread: 0x608000068540>{number = 1, name = main}
2017-08-16 22:57:16.706 JJOC[2271:56082] 3--<NSThread: 0x608000068540>{number = 1, name = main}
2017-08-16 22:57:16.706 JJOC[2271:56082] 4--<NSThread: 0x608000068540>{number = 1, name = main}
2017-08-16 22:57:16.707 JJOC[2271:56082] 5--<NSThread: 0x608000068540>{number = 1, name = main}
2017-08-16 22:57:16.707 JJOC[2271:56082] 6--<NSThread: 0x608000068540>{number = 1, name = main}
2017-08-16 22:57:16.707 JJOC[2271:56082] 7--<NSThread: 0x608000068540>{number = 1, name = main}
2017-08-16 22:57:16.707 JJOC[2271:56082] 8--<NSThread: 0x608000068540>{number = 1, name = main}
2017-08-16 22:57:16.707 JJOC[2271:56082] 9--<NSThread: 0x608000068540>{number = 1, name = main}

结论：由上可知

  • 没有开启新的线程。
  • 任务是串行执行的。

5. 主队列 + 同步任务

看代码。

#import "JJQueueStatusVC.h"

@interface JJQueueStatusVC ()

@end

@implementation JJQueueStatusVC

#pragma mark - Override Base Function

- (void)viewDidLoad
{
    [super viewDidLoad];
    
    self.view.backgroundColor = [UIColor whiteColor];
    
    [self mainAndSync];
}

#pragma mark - Object Private Function

//主队列 + 同步任务

- (void)mainAndSync
{
    //主队列
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    NSLog(@"线程 = %@",[NSThread currentThread]);
    
    dispatch_sync(queue, ^{
        NSLog(@"thread = %@",[NSThread currentThread]);
    });
    
    NSLog(@"我被阻塞了");
}

@end

下面看输出结果

2017-08-16 23:20:23.406 JJOC[2985:72806] 线程 = <NSThread: 0x600000067340>{number = 1, name = main}

结论：由上可知NSLog(@"我被阻塞了");并没有执行和输出，也就是说主线程发生了死锁。这里要说一下发生死锁的原因：在主队列开启同步任务，因为主队列是串行队列，里面的线程是有顺序的，先执行完一个线程才执行下一个线程，而主队列始终就只有一个主线程，主线程是不会执行完毕的，因为他是无限循环的，除非关闭应用程序。因此在主线程开启一个同步任务，同步任务会想抢占执行的资源，而主线程任务一直在执行某些操作，不肯放手。两个的优先级都很高，最终导致死锁，阻塞线程了。

6. 主队列 + 异步任务

下面还是直接看代码。

#import "JJQueueStatusVC.h"

@interface JJQueueStatusVC ()

@end

@implementation JJQueueStatusVC

#pragma mark - Override Base Function

- (void)viewDidLoad
{
    [super viewDidLoad];
    
    self.view.backgroundColor = [UIColor whiteColor];
        
    [self mainAndAsync];
}

#pragma mark - Object Private Function

//主队列 + 异步任务

- (void)mainAndAsync
{
    //主队列
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    for (NSInteger i = 0; i < 10; i ++) {
        //创建要执行的任务
        void(^task)() = ^{
            NSLog(@"%ld--%@",i, [NSThread currentThread]);
        };
        
        //将任务添加到队列
        dispatch_async(queue, task);
    }
}

@end

下面看输出结果

2017-08-16 23:26:27.616 JJOC[3226:78118] 0--<NSThread: 0x600000077ac0>{number = 1, name = main}
2017-08-16 23:26:27.616 JJOC[3226:78118] 1--<NSThread: 0x600000077ac0>{number = 1, name = main}
2017-08-16 23:26:27.616 JJOC[3226:78118] 2--<NSThread: 0x600000077ac0>{number = 1, name = main}
2017-08-16 23:26:27.617 JJOC[3226:78118] 3--<NSThread: 0x600000077ac0>{number = 1, name = main}
2017-08-16 23:26:27.617 JJOC[3226:78118] 4--<NSThread: 0x600000077ac0>{number = 1, name = main}
2017-08-16 23:26:27.617 JJOC[3226:78118] 5--<NSThread: 0x600000077ac0>{number = 1, name = main}
2017-08-16 23:26:27.617 JJOC[3226:78118] 6--<NSThread: 0x600000077ac0>{number = 1, name = main}
2017-08-16 23:26:27.618 JJOC[3226:78118] 7--<NSThread: 0x600000077ac0>{number = 1, name = main}
2017-08-16 23:26:27.618 JJOC[3226:78118] 8--<NSThread: 0x600000077ac0>{number = 1, name = main}
2017-08-16 23:26:27.618 JJOC[3226:78118] 9--<NSThread: 0x600000077ac0>{number = 1, name = main}

结论：由上可知

  • 没有开启新的线程，主队列只有主线程。
  • 任务是串行执行的。

7. 全局队列 + 同步任务

直接看代码。

#import "JJQueueStatusVC.h"

@interface JJQueueStatusVC ()

@end

@implementation JJQueueStatusVC

#pragma mark - Override Base Function

- (void)viewDidLoad
{
    [super viewDidLoad];
    
    self.view.backgroundColor = [UIColor whiteColor];
    
    [self mainAndAsync];
}

#pragma mark - Object Private Function

//全局队列 + 同步任务

- (void)globalAndSync
{
    //全局队列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    for (NSInteger i = 0; i < 10; i ++) {
        //创建要执行的任务
        void(^task)() = ^{
            NSLog(@"%ld--%@",i, [NSThread currentThread]);
        };
        
        //将任务添加到队列
        dispatch_sync(queue, task);
    }
}

@end

下面看输出结果

2017-08-16 23:31:38.182 JJOC[3381:82695] 0--<NSThread: 0x600000068a80>{number = 1, name = main}
2017-08-16 23:31:38.183 JJOC[3381:82695] 1--<NSThread: 0x600000068a80>{number = 1, name = main}
2017-08-16 23:31:38.183 JJOC[3381:82695] 2--<NSThread: 0x600000068a80>{number = 1, name = main}
2017-08-16 23:31:38.183 JJOC[3381:82695] 3--<NSThread: 0x600000068a80>{number = 1, name = main}
2017-08-16 23:31:38.184 JJOC[3381:82695] 4--<NSThread: 0x600000068a80>{number = 1, name = main}
2017-08-16 23:31:38.184 JJOC[3381:82695] 5--<NSThread: 0x600000068a80>{number = 1, name = main}
2017-08-16 23:31:38.184 JJOC[3381:82695] 6--<NSThread: 0x600000068a80>{number = 1, name = main}
2017-08-16 23:31:38.184 JJOC[3381:82695] 7--<NSThread: 0x600000068a80>{number = 1, name = main}
2017-08-16 23:31:38.184 JJOC[3381:82695] 8--<NSThread: 0x600000068a80>{number = 1, name = main}
2017-08-16 23:31:38.185 JJOC[3381:82695] 9--<NSThread: 0x600000068a80>{number = 1, name = main}

结论：由上可知

  • 没有开启新的线程。
  • 任务是串行执行的。

8. 全局队列 + 异步任务

下面还是直接看代码。

#import "JJQueueStatusVC.h"

@interface JJQueueStatusVC ()

@end

@implementation JJQueueStatusVC

#pragma mark - Override Base Function

- (void)viewDidLoad
{
    [super viewDidLoad];
    
    self.view.backgroundColor = [UIColor whiteColor];
    
    [self globalAndAsync];
}

#pragma mark - Object Private Function

//全局队列 + 异步任务

- (void)globalAndAsync
{
    //全局队列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    for (NSInteger i = 0; i < 10; i ++) {
        //创建要执行的任务
        void(^task)() = ^{
            NSLog(@"%ld--%@",i, [NSThread currentThread]);
        };
        
        //将任务添加到队列
        dispatch_async(queue, task);
    }
}

@end

下面看输出结果

2017-08-16 23:34:46.735 JJOC[3515:85791] 2--<NSThread: 0x608000261c00>{number = 5, name = (null)}
2017-08-16 23:34:46.735 JJOC[3515:85790] 0--<NSThread: 0x608000261600>{number = 3, name = (null)}
2017-08-16 23:34:46.735 JJOC[3515:85809] 1--<NSThread: 0x600000268080>{number = 4, name = (null)}
2017-08-16 23:34:46.735 JJOC[3515:85793] 3--<NSThread: 0x600000268400>{number = 6, name = (null)}
2017-08-16 23:34:46.735 JJOC[3515:85811] 4--<NSThread: 0x608000262380>{number = 7, name = (null)}
2017-08-16 23:34:46.735 JJOC[3515:85791] 6--<NSThread: 0x608000261c00>{number = 5, name = (null)}
2017-08-16 23:34:46.735 JJOC[3515:85812] 5--<NSThread: 0x608000262700>{number = 8, name = (null)}
2017-08-16 23:34:46.735 JJOC[3515:85790] 7--<NSThread: 0x608000261600>{number = 3, name = (null)}
2017-08-16 23:34:46.735 JJOC[3515:85813] 8--<NSThread: 0x608000262740>{number = 9, name = (null)}
2017-08-16 23:34:46.736 JJOC[3515:85809] 9--<NSThread: 0x600000268080>{number = 4, name = (null)}

结论：由上可知

  • 开启新的线程。
  • 任务是并行执行的。

参考文章

1. iOS中多线程知识总结：进程、线程、GCD、串行队列、并行队列、全局队列、主线程队列、同步任务、异步任务等（有示例代码）

后记

未完，待续~~~

秋天码头

相关文章

  • 串并行和同异步之间的关系

    串并行和同异步之间的关系

  • 串并行和同异步之间的关系

    版本记录 前言 ios中有串行和并行、同步和异步的概念，这些概念并不难，但是仍然需要大家好好的理解，这一篇就详细的...

  • 多线程GCD的使用

    一、同步/异步、串行/并行的区别 1.同步/异步 同步/异步是指线程与线程之间的关系。 2.串行/并行 串行、并行...

  • GCD 小结

    一、 同步/异步、串行/并行的区别 1.同步/异步 同步/异步是指线程与线程之间的关系. 2.串行/并行 串行/并...

  • iOS GCD_1

    这篇主要写的是1、同异步派发（dispatch_async、dispatch_sync）2、串并行队列（DISPA...

  • iOS 整理-线程篇

    什么是进程和线程进程和线程之间的关系什么是任务和队列多线程中同步异步，串行并行iOS中多线程的区别：NSThrea...

  • 2017-10-19-同步和异步

    同步和异步 1，同步 2，异步 并发和并行都是异步任务实现的俩种方式 3，并发 4，并行 总结：并行是相对于多核C...

  • 同步&异步 与 串行&并行的区别

    一、 同步&异步：指的是能否开启新的线程。同步不能开启新的线程，异步可以。二、串行&并行：指的是任务的执行方式。串...

  • ObjC-多线程之GCD

    介绍 基本概念 串行和并行 并发和并行 下图描述的就是并发和并行的区别。 同步和异步 函数说明 Dispatch ...

  • 数字IC设计笔试题（连续更新）

    1：什么是同步逻辑和异步逻辑？ 同步逻辑：是时钟之间有固定的因果关系。 异步逻辑：是各时钟之间没有固定的因果关系。...

网友评论

    本文标题：串并行和同异步之间的关系

    本文链接：https://www.haomeiwen.com/subject/dqkwrxtx.html

    延伸阅读

    深度阅读

    • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

    栏目导航

    热点阅读

    iOS线程

    iOS开发之常用技术点

    iOS开发之常见问题

    iOS/MAC 底层原理

    关于我们|服务条款|联系我们|串并行和同异步之间的关系|投稿指南|网站地图|RSS订阅|排版工具|手机版

    提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

    Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

    备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

    本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

    所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！