美文网首页
多线程之GCD使用

多线程之GCD使用

作者: 梦里桃花舞倾城 | 来源:发表于2019-02-28 13:51 被阅读0次

上文已经介绍了GCD的一些基本概念多线程操作之GCD概述

GCD 的使用步骤

  1. 创建一个队列（串行队列或并发队列）
  2. 将任务追加到任务的等待队列中，然后系统会根据任务类型执行任务（同步执行或异步执行）

1.队列的创建

可以使用dispatch_queue_create来创建队列，需要传入两个参数，参数一表示：队列的唯一标识符，用于 DEBUG，可为空；参数二：用来识别是串行队列还是并发队列。DISPATCH_QUEUE_SERIAL 表示串行队列，DISPATCH_QUEUE_CONCURRENT 表示并发队列。

    // 串行队列
    dispatch_queue_t seralQueue = dispatch_queue_create("xxx", DISPATCH_QUEUE_SERIAL);
    // 并发队列
    dispatch_queue_t conQueue = dispatch_queue_create("xxx", DISPATCH_QUEUE_CONCURRENT);
  • 对于串行队列，GCD提供了一个特殊的串行队列，主队列Main Dispatch Queue
  • 所有放在主队列中的任务，都会放到主线程中执行，不会开辟新的线程。
  • 可使用dispatch_get_main_queue()获得主队列。
    //主队列的获取方法
    dispatch_get_main_queue()
  • 对于并发队列，GCD默认提供了全局并发队列
  • 可以使用dispatch_get_global_queue来获取。参数一：表示队列优先级，一般用DISPATCH_QUEUE_PRIORITY_DEFAULT或者0，参数二: 一般用0即可
    //全局并发队列的获取方法
    dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)

2. 任务的创建

  • GCD提供了同步执行任务的创建方法为：dispatch_sync
  • 异步执行任务的创建方法为：dispatch_async 
// 同步执行任务创建方法
dispatch_sync(queue, ^{
    // 这里放同步执行任务代码
});
// 异步执行任务创建方法
dispatch_async(queue, ^{
    // 这里放异步执行任务代码
});

在这里可以看出，执行任务的时候需要添加相应的队列（串行队列or并发队列）；组合起来就有四种不同的方式：

  1. 同步执行 + 并发队列
  2. 异步执行 + 并发队列
  3. 同步执行 + 串行队列
  4. 异步执行 + 串行队列

注意这里还有上面说的两种队列：全局并发队列和主队列。全局并发队列可以作为普通并发队列来使用。但是主队列因为有点特殊，加一起就6种不同的组合方式了

  1. 同步执行 + 主队列
  2. 异步执行 + 主队列

3.GCD的基本使用

先来讲讲并发队列的两种执行方式。

3.1 同步执行 + 并发队列

在当前线程中执行任务，不会开启新线程，执行完一个任务之后再执行下一个任务。

/**
 * 同步执行 + 并发队列
 * 特点：在当前线程中执行任务，不会开启新线程，执行完一个任务，再执行下一个任务。
 */
- (void)syncConcurrent {
    NSLog(@"currentThread------------>%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"----------------->begin");
    dispatch_queue_t queue = dispatch_queue_create("YX_queue", 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]);      // 打印当前线程
        }
    });
    NSLog(@"----------------->end");
}

输出结果

 currentThread----------><NSThread: 0x600000e22940>{number = 1, name = main}
 ----------------------->begin
 1----------------------><NSThread: 0x600000e22940>{number = 1, name = main}
 1----------------------><NSThread: 0x600000e22940>{number = 1, name = main}
 2----------------------><NSThread: 0x600000e22940>{number = 1, name = main}
 2----------------------><NSThread: 0x600000e22940>{number = 1, name = main}
 ----------------------->end

从同步执行 + 并发队列中可看到：

  • 所有任务都在当前线程（主线程）中执行，没有开启新的线程（同步执行不具备开启新线程的能力）
  • 所有任务都在打印的---begin和---end之间执行的（同步任务需要等待队列的任务执行结束，才能执行下一个）
  • 任务按顺序执行的。不能同时被执行。按顺序执行的原因：虽然 并发队列可以开启多个线程，并且同时执行多个任务。但是因为本身不能创建新线程，只有当前线程这一个线程（同步任务不具备开启新线程的能力），所以也就不存在并发。而且当前线程只有等待当前队列中正在执行的任务执行完毕之后，才能继续接着执行下面的操作（同步任务需要等待队列的任务执行结束）。所以任务只能一个接一个按顺序执行，不能同时被执行。

3.2 异步执行 + 并发队列

可以开启多个线程，任务交替（同时）执行。

/**
 * 异步执行 + 并发队列
 * 特点：可以开启多个线程, 任务交替 (同时) 执行。
 */
- (void)asyncConcurrent {
    NSLog(@"currentThread------------>%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"----------------->begin");
    dispatch_queue_t queue = dispatch_queue_create("YX_queue", 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]);      // 打印当前线程
        }
    });
    NSLog(@"----------------->end");
}

输出结果

 currentThread------------><NSThread: 0x600003e7e900>{number = 1, name = main}
 ----------------->begin
 ----------------->end
 1----------------------><NSThread: 0x6000031d14c0>{number = 3, name = (null)}
 2----------------------><NSThread: 0x6000031c7ac0>{number = 4, name = (null)}
 2----------------------><NSThread: 0x6000031c7ac0>{number = 4, name = (null)}
 1----------------------><NSThread: 0x6000031d14c0>{number = 3, name = (null)}

从异步执行+并发队列中可以看出

  • 除了当前线程（主线程），系统又新开启了2个新线程，并且任务是 同时/交替 执行的（异步执行具备开启新线程的能力，且并发队列可开启多个线程，同时执行多个任务）
  • 所有任务都是从打印---begin和---end之后才执行的，说明当前线程没有等待，而是直接开启了新的线程，在新线程中执行任务（异步执行不做等待，可以继续执行任务）

接下来再来说说串行队列的两种执行方式。

3.3 同步执行 + 串行队列

不会开启新线程，在当前线程执行任务。任务是串行的，执行完一个任务，再执行下一个任务。

/*
 * 同步执行 + 串行队列
 * 特点: 不会开启新线程，在当前线程执行任务。任务是串行的，执行完一个任务，再执行下一个任务。
 */
- (void)syncSerial {
    NSLog(@"currentThread---------->%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@" ----------------------->begin");
    dispatch_queue_t queue = dispatch_queue_create("YX_queue", DISPATCH_QUEUE_SERIAL);
    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]);      // 打印当前线程
        }
    });
    NSLog(@" ----------------------->end");
}

输出结果

 currentThread----------><NSThread: 0x600000abd400>{number = 1, name = main}
 ----------------------->begin
 1----------------------><NSThread: 0x600000abd400>{number = 1, name = main}
 1----------------------><NSThread: 0x600000abd400>{number = 1, name = main}
 2----------------------><NSThread: 0x600000abd400>{number = 1, name = main}
 2----------------------><NSThread: 0x600000abd400>{number = 1, name = main}
 ----------------------->end

从同步执行 + 串行队列可以看到：

  • 同 同步执行 + 并发队列类似
  • 所有任务都在当前线程（主线程）中执行，没有开启新的线程（同步执行不具备开启新线程的能力）
  • 所有任务都在打印的---begin和---end之间执行的（同步任务需要等待队列的任务执行结束，才能执行下一个）
  • 任务按顺序执行的，只能一个接一个按顺序执行（串行队列每次只有一个任务被执行，任务一个接一个按顺序执行）

3.4 异步执行 + 串行队列

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

/**
 * 异步执行 + 串行队列
 * 特点：会开启新线程，但是因为任务是串行的，执行完一个任务，再执行下一个任务。
 */
- (void)asyncSerial {
    NSLog(@"currentThread---------->%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@" ----------------------->begin");
    dispatch_queue_t queue = dispatch_queue_create("YX_queue", 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]);      // 打印当前线程
        }
    });
    NSLog(@" ----------------------->end");
}

输出结果

 currentThread----------><NSThread: 0x600002976940>{number = 1, name = main}
 ----------------------->begin
 ----------------------->end
 1----------------------><NSThread: 0x6000026a0400>{number = 3, name = (null)}
 1----------------------><NSThread: 0x6000026a0400>{number = 3, name = (null)}
 2----------------------><NSThread: 0x6000026a0400>{number = 3, name = (null)}
 2----------------------><NSThread: 0x6000026a0400>{number = 3, name = (null)}
 3----------------------><NSThread: 0x6000026a0400>{number = 3, name = (null)}
 3----------------------><NSThread: 0x6000026a0400>{number = 3, name = (null)}

在异步执行 + 串行队列中可以看到：

  • 只开启了一个新线程（异步执行具备开启新线程的能力，串行队列只开启一个线程）。
  • 所有任务都在打印的---begin和---end之后执行的（异步执行不需要任何等待，可以继续执行任务）
  • 任务是按顺序执行的（串行队列每次只有一个任务被执行，任务一个接一个按顺序执行）。

主队列

主队列是GCD自带的一种特殊的串行队列

我们再来看看主队列的两种组合方式。

3.5 同步执行 + 主队列

同步执行 + 主队列 在不同线程中调用结果也是不一样，在主线程中调用会出现 死锁 ，而在其他线程中则不会。

3.5.1 在主线程中调用 同步执行 + 主队列

互相等待卡住不可行

/**
 * 同步执行 + 主队列
 * 特点(主线程调用)：互等卡主不执行。
 * 特点(其他线程调用)：不会开启新线程，执行完一个任务，再执行下一个任务。
 */
- (void)syncMain {
    NSLog(@"currentThread---------->%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@" ----------------------->begin");
    dispatch_queue_t queue = dispatch_get_main_queue();
    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]);      // 打印当前线程
        }
    });
    NSLog(@" ----------------------->end");
}

输出结果

 currentThread----------><NSThread: 0x600001397ac0>{number = 1, name = main}
 ----------------------->begin
(lldb)

在同步执行 + 主队列中可以发现

  • 在主线程中使用同步执行 + 主队列，追加到主线程的任务1、任务2都不再执行了，而且--end也没有打印，在XCode 9上还会报崩溃。这是为什么呢？

这是因为我们在主线程中执行syncMain方法，相当于把syncMain任务放到了主线程的队列中。而同步执行会等待当前队列中的任务执行完毕，才会接着执行。那么当我们把任务1追加到主队列中，任务1就在等待主线程处理完syncMain任务。而syncMain任务需要等待任务1执行完毕，才能接着执行。形成了相互等待！

所以，现在的情况就是syncMain任务和任务1都在等对方执行完毕。这样大家互相等待，所以就卡住了，所以我们的任务执行不了，而且---end也没有打印。

要是如果不在主线程中调用，而在其他线程中调用会如何呢？

3.5.2 在其他线程中调用 同步执行 + 主队列

不会开启新线程，执行完一个任务，再执行下一个任务。

    // 使用 NSThread 的 detachNewThreadSelector 方法会创建线程，并自动启动线程执行selector 任务
    [NSThread detachNewThreadSelector:@selector(syncMain) toTarget:self withObject:nil];

输出结果

 currentThread----------><NSThread: 0x60000193c040>{number = 3, name = (null)}
 ----------------------->begin
 1----------------------><NSThread: 0x6000016b2480>{number = 1, name = main}
 1----------------------><NSThread: 0x6000016b2480>{number = 1, name = main}
 2----------------------><NSThread: 0x6000016b2480>{number = 1, name = main}
 2----------------------><NSThread: 0x6000016b2480>{number = 1, name = main}
 ----------------------->end

在其他线程中使用同步执行 + 主队列 可看到：

  • 所有任务都是在主线程（非当前线程）中执行的，没有开启新的线程（所有放在主队列中的任务，都会放到主线程中执行）。
  • 所有任务都在打印的---begin和---end之间执行（同步任务需要等待队列的任务执行结束）。
  • 任务是按顺序执行的（主队列是串行队列，每次只有一个任务被执行，任务一个接一个按顺序执行）。

为什么现在就不会卡住了呢？
因为syncMain 任务放到了其他线程里，而任务1、任务2都在追加到主队列中，这三个任务都会在主线程中执行。syncMain 任务在其他线程中执行到追加任务1到主队列中，因为主队列现在没有正在执行的任务，所以，会直接执行主队列的任务1，等任务1执行完毕，再接着执行任务2,所以这里不会卡住线程。

4.6 异步执行 + 主队列

只在主线程中执行任务，执行完一个任务，再执行下一个任务。

/**
 * 异步执行 + 主队列
 * 特点：只在主线程中执行任务，执行完一个任务，再执行下一个任务
 */
- (void)asyncMain {
    NSLog(@"currentThread---------->%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@" ----------------------->begin");
    dispatch_queue_t queue = dispatch_get_main_queue();
    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]);      // 打印当前线程
        }
    });
    NSLog(@" ----------------------->end");
}

输出结果

 currentThread----------><NSThread: 0x600002feb540>{number = 1, name = main}
 ----------------------->begin
 ----------------------->end
 1----------------------><NSThread: 0x600002feb540>{number = 1, name = main}
 1----------------------><NSThread: 0x600002feb540>{number = 1, name = main}
 2----------------------><NSThread: 0x600002feb540>{number = 1, name = main}
 2----------------------><NSThread: 0x600002feb540>{number = 1, name = main}

在异步执行 + 主队列 可以看到：

  • 所有任务都是在当前线程（主线程）中执行的，并没有开启新的线程（虽然异步执行具备开启线程的能力，但因为是主队列，所以所有任务都在主线程中）。
  • 所有任务是在打印的---begin和---end之后才开始执行的（异步执行不会做任何等待，可以继续执行任务）。
  • 任务是按顺序执行的（因为主队列是串行队列，每次只有一个任务被执行，任务一个接一个按顺序执行）

相关文章

  • GCD异步

    GCD多线程的使用

  • 多线程之GCD

    线程、多线程 多线程存在的问题 为什么使用多线程？ GCD GCD 的 API 介绍Dispatch QueueD...

  • 多线程

    参考文章：iOS多线程--彻底学会多线程之『GCD』Swift 3.0 GCD和DispatchQueue 使用解...

  • iOS开发多线程之GCD

    iOS开发多线程之GCDiOS开发之GCD同步任务加强iOS开发之GCD串行队列iOS开发之GCD并发队列 GCD...

  • 多线程之GCD使用

    上文已经介绍了GCD的一些基本概念多线程操作之GCD概述 GCD 的使用步骤 创建一个队列（串行队列或并发队列） ...

  • iOS开发之GCD并发队列

    iOS开发多线程之GCDiOS开发之GCD同步任务加强iOS开发之GCD串行队列iOS开发之GCD并发队列 03 ...

  • iOS开发之GCD同步任务加强

    iOS开发多线程之GCDiOS开发之GCD同步任务加强iOS开发之GCD串行队列iOS开发之GCD并发队列 004...

  • iOS多线程NSThread/GCD/NSOperation区别

    iOS多线程NSThread/GCD/NSOperation区别和使用

  • iOS开发之GCD串行队列

    iOS开发多线程之GCDiOS开发之GCD同步任务加强iOS开发之GCD串行队列iOS开发之GCD并发队列 实例d...

  • FLAnimatedImageView加载卡顿问题。

    GCD 的调用 转载“iOS多线程编程之Grand Central Dispatch(GCD)介绍和使用”

网友评论

      本文标题：多线程之GCD使用

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

      延伸阅读

      深度阅读

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

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|多线程之GCD使用|投稿指南|网站地图|RSS订阅|排版工具|手机版

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

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

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

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

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