[iOS 多线程] iOS多线程-GCD

iOS多线程-GCD

GCD.png

GCD的简介

GCD，全称为 Grand Central Dispatch ，是iOS用来管理线程的技术。 纯C语言，提供了非常多强大的函数。

GCD的优势

• GCD会自动利用更多的CPU内核（比如双核、四核）。
• GCD会自动管理线程的生命周期（创建线程、调度任务、销毁线程）。
• 程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码。

GCD的中的概念

线程、任务和队列的概念

概念	含义
队列(Dispatch Queue)	装载线程任务的队形结构
并行队列(Concurrent Dispatch Queue)	并行队列只能保证任务按照加入的顺序开始执行，但是任务执行结束的时间无法保证
串行队列(Serial Dispatch Queue)	串行队列一次只能执行一个任务 只能依次逐一先后有序的执行,等待上一个执行完，再执行下一个。
同步	不具备开启新线程能力，任务创建后就要执行完毕才能继续运行下一步
异步	具备开启新线程能力，任务创建后可以先绕过，回头再执行

Serial-Queue-480x272.png

Concurrent-Queue-480x272.png

创建队列

//全局队列，一个并行的队列
dispatch_get_global_queue
//主队列，主线程中的唯一队列，一个串行队列
dispatch_get_main_queue
自定义队列
//串行队列
dispatch_queue_create("serialqueue", DISPATCH_QUEUE_SERIAL)
//并行队列
dispatch_queue_create("concurrentqueue", DISPATCH_QUEUE_CONCURRENT)
同步异步线程创建
//同步
dispatch_sync(..., ^(block))
//异步
dispatch_async(..., ^(block))

队列和线程的区别

简单来说，队列就是用来存放任务的“暂存区”，而线程是执行任务的路径，GCD将这些存在于队列的任务取出来放到相应的线程上去执行，而队列的性质决定了在其中的任务在哪种线程上执行

1214547-7490d67912ed239e.png

串行并行同步异步 - 简单组合案例

使用GCD的核心问题

• 是否开启新的线程
• 任务可以同时执行
• 结合以上两个条件，也就等价“开启新线程的能力 + 任务同步执行的权利”，只有在满足能力与权利这两个条件的前提下，我们才可以在同时执行多个任务。

再次进行多个实验，其中要控制的变量有

• 同步或者异步
• 串行、并行、主队列
• 外部任务和内部任务 所处队列 **外部任务指的是出gcd派发的任务， 而内部任务是gcd派发的任务**

异步+串行

 - (void)TestFunc
{
    dispatch_queue_t squeue = dispatch_queue_create("serial.queue", DISPATCH_QUEUE_SERIAL);
    NSLog(@"Begin----%@", [NSThread currentThread]);
    dispatch_async(squeue, ^{ 
        NSLog(@"Task 1---%@", [NSThread currentThread]);
    });
    dispatch_async(dispatch_get_main_queue(), ^{ 
        NSLog(@"Task 2---%@", [NSThread currentThread]);
    });
    NSLog(@"End -----%@", [NSThread currentThread]);
}
//  输出
     Begin----{number = 1, name = main}
     End -----{number = 1, name = main}
     Task 2---{number = 1, name = main}
     Task 1---{number = 2, name = (null)}

结论分析

1. 异步执行不会阻塞队列，所以TestFunc会执行Begin后马上执行End，TestFunc完成
2. 异步+串行队列可以开启一个新线程 ，所以Task 1线程是2
3. 异步+主队列不开启新线程，所以Task 2仍在线程1

异步串行.png

异步+并行 ：开启新的线程，同时执行

 dispatch_queue_t  c_queue = dispatch_queue_create("标识符", DISPATCH_QUEUE_CONCURRENT);
   NSLog(@"Begin----%@", [NSThread currentThread]);
    //使用异步函数封装三个任务
    dispatch_async(c_queue, ^{
        NSLog(@"Task 1---%@", [NSThread currentThread]);
    });
    dispatch_async(c_queue, ^{
        NSLog(@"test 2---%@", [NSThread currentThread]);
    });
    dispatch_async(c_queue, ^{
        NSLog(@"Task 3---%@", [NSThread currentThread]);
    });
   NSLog(@"End -----%@", [NSThread currentThread]);

    // 输出
   Begin----{number = 1, name = main}
   End -----{number = 1, name = main}
   Task 2---{number = 3, name = (null)}
   Task 1---{number = 2, name = (null)}
   Task 3---{number = 4, name = (null)}

结论分析

• 两者组合后的结果 开了三个新线程
• 函数在执行时，head和tail线，再回头执行这三个任务
• 这三个任务是同时执行的，没有先后，所以打印结果是“1-->3-->2”

同步+串行

//  情况 1： 内外分别属于两个不同的串行队列
dispatch_queue_t  s_queue = dispatch_queue_create("标识符", DISPATCH_QUEUE_SERIAL);
    NSLog(@"Begin----%@", [NSThread currentThread]);
    //使用异步函数封装三个任务
    dispatch_sync(s_queue, ^{
        NSLog(@"Task 1---%@", [NSThread currentThread]);
    });
    dispatch_sync(s_queue, ^{
        NSLog(@"Task 2---%@", [NSThread currentThread]);
    }); 
   NSLog(@"End -----%@", [NSThread currentThread]);
 // 输出1
  Begin----{number = 1, name = main}
  Task 1---{number = 1, name = main}
  Task 2---{number = 1, name = main} 
  End -----{number = 1, name = main}
// 情况 2  内外分别属于同一个的串行队列  类似 /**同步+主队列**/
 dispatch_queue_t  s_queue = dispatch_queue_create("标识符", DISPATCH_QUEUE_SERIAL);
    NSLog(@"Begin----%@", [NSThread currentThread]);
    dispatch_async(s_queue, ^{
         NSLog(@"Begin 2---%@", [NSThread currentThread]);
        dispatch_sync(s_queue, ^{
            NSLog(@"Task 1---%@", [NSThread currentThread]);
        });
        dispatch_sync(s_queue, ^{
            NSLog(@"Task 2---%@", [NSThread currentThread]);
        });
         NSLog(@"End 2-----%@", [NSThread currentThread]);
    });   
    NSLog(@"End -----%@", [NSThread currentThread]);
 // 输出2
   Begin----{number = 1, name = main}
    End -----{number = 1, name = main}
    Begin 2---{number = 2, name = (null)}

结论

1. 当外部任务和同步执行的内部任务处于一个串行队列时会导致死锁
2. 当外部任务和同步执行的内部任务分别处于两个串行队列是不会死锁
3. 虽然有两个串行队列，但是并没有两个线程

同步串行2.png

同步+并行

 dispatch_queue_t c_queue = dispatch_queue_create("标识符", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"Begin----%@", [NSThread currentThread]);
    //使用异步函数封装三个任务
    dispatch_sync(c_queue, ^{
        NSLog(@"Task 1---%@", [NSThread currentThread]);
    });
    dispatch_sync(c_queue, ^{
        NSLog(@"Task 2---%@", [NSThread currentThread]);
    });
    dispatch_sync(c_queue, ^{
        NSLog(@"Task 3---%@", [NSThread currentThread]);
    });
    NSLog(@"End -----%@", [NSThread currentThread]);

结论分析

• 同步执行执行意味着
  1. 不能开启新的线程
  2. 任务创建后必须执行完才能往下走
• 并行队列意味着
  1. 任务之间不需要排队，且具有同时被执行的“”
• 两者组合后的结果
  1. 所有任务都只能在主线程中执行
  2. 函数在执行时，必须按照代码的书写顺序一行一行地执行完才能继续
• 注意事项
  在这里即便是并行队列，任务可以同时执行，但是由于只存在一个主线程，所以没法把任务分发到不同的线程去同步处理，其结果就是只能在主线程里按顺序挨个挨个执行了

异步+主队列 ：所有任务都可以先跳过，之后再来“按顺序”执行

同步+主队列 ：死锁

3007158-6f6a652495d9e38e.png

串行并行同步异步 - 复杂组合案例

声明：本文非原创，仅仅整理一些开发技能知识文章，以作存档学习用
参考
[1] http://www.jianshu.com/p/414b8e91e021 // 这篇文章中有很多东西都无法解释通顺
[2] http://www.devhua.com/2016/01/25/iOS-GCD-deadlock/
[3] https://objccn.io/issue-2-1/
[4]http://www.jianshu.com/p/bbabef8aa1fe // 死锁的解释和 1 不同，似乎是可以解释通
[5]https://www.raywenderlich.com/60749/grand-central-dispatch-in-depth-part-1 // 有动图！！

======

感慨： 之前在中搜集了很多GCD和死锁的文章，比如参考1中，认为死锁是因为线程阻塞了，阻塞的任务被加入到串行队列，并且位于下一个任务的后边，形成环形等待，所以死锁， 但是一直疑问，为什么阻塞了， 下一个任务还可以被加入队列，解释不通啊，
参考4 中认为死锁是队列阻塞而不是线程，内部任务即同步阻塞任务在队列头部，而外部任务正在执行，外部任务等待内部任务结束才可以结束， 而内部任务却在等待执行， 说起来恨到看图吧