GCD 学习总结

时间 2019-12-05

标签 gcd 学习总结繁體版

原文原文链接

GCD

GCD中两个很是重要的概念：任务和队列数据库

任务分为同步执行sync和异步执行async, 同步和异步的区别在因而否会阻塞当前线程, 其实在GCD中一个任务就是一个block中的代码.安全

队列分为串行队列和并行队列,主队列dispatch_get_main_queue( )是串行队列.多线程

咱们可使用dispatch_queue_create来建立新的队列,异步

//串行队列
  dispatch_queue_t queue = dispatch_queue_create("testQueue", NULL);
  dispatch_queue_t queue = dispatch_queue_create("testQueue", DISPATCH_QUEUE_SERIAL);
  //并行队列
  dispatch_queue_t queue = dispatch_queue_create("testQueue", DISPATCH_QUEUE_CONCURRENT);

下面是我本身总结的:async

/	同步执行sync	异步执行async
串行队列	当前线程,一个一个执行	其余一个线程, 一个一个执行
并行队列	当前线程,一个一个执行	其余一个或者多个线程(取决于任务数), 同时执行

经过代码来验证一下:函数

建立一个串行的队列添加4个同步执行的任务spa

//串行队列
  dispatch_queue_t queue = dispatch_queue_create("testQueue", DISPATCH_QUEUE_SERIAL); 
  dispatch_sync(queue, ^{
      NSLog(@"111");
      NSLog(@"111中 %@",[NSThread currentThread]);
  });
  dispatch_sync(queue, ^{
      NSLog(@"222");
      NSLog(@"222中 %@",[NSThread currentThread]);
  });
  dispatch_sync(queue, ^{
      NSLog(@"333");
      NSLog(@"333中 %@",[NSThread currentThread]);
  });
  dispatch_sync(queue, ^{
      NSLog(@"444");
      NSLog(@"444中 %@",[NSThread currentThread]);
  });

打印结果:线程

2018-03-09 15:34:26.474786+0800 Learning[3385:281473] 111
2018-03-09 15:34:26.475053+0800 Learning[3385:281473] 111中 <NSThread: 
0x60000007a2c0>{number = 1, name = main}
2018-03-09 15:34:26.475165+0800 Learning[3385:281473] 222
2018-03-09 15:34:26.475369+0800 Learning[3385:281473] 222中 <NSThread: 
0x60000007a2c0>{number = 1, name = main}
2018-03-09 15:34:26.475568+0800 Learning[3385:281473] 333
2018-03-09 15:34:26.476057+0800 Learning[3385:281473] 333中 <NSThread: 
0x60000007a2c0>{number = 1, name = main}
2018-03-09 15:34:26.476249+0800 Learning[3385:281473] 444
2018-03-09 15:34:26.476351+0800 Learning[3385:281473] 444中 <NSThread: 
0x60000007a2c0>{number = 1, name = main}

同步dispatch_sync改成异步dispatch_async
打印结果依然是有序, 可是开启了一个子线程3d

2018-03-09 16:23:47.634329+0800 Learning[3830:331376] 111
2018-03-09 16:23:47.634739+0800 Learning[3830:331376] 111中 <NSThread: 
0x604000274dc0>{number = 4, name = (null)}
2018-03-09 16:23:47.634911+0800 Learning[3830:331376] 222
2018-03-09 16:23:47.635262+0800 Learning[3830:331376] 222中 <NSThread: 
0x604000274dc0>{number = 4, name = (null)}
2018-03-09 16:23:47.636508+0800 Learning[3830:331376] 333
2018-03-09 16:23:47.637206+0800 Learning[3830:331376] 333中 <NSThread: 
0x604000274dc0>{number = 4, name = (null)}
2018-03-09 16:23:47.637413+0800 Learning[3830:331376] 444
2018-03-09 16:23:47.637680+0800 Learning[3830:331376] 444中 <NSThread: 
0x604000274dc0>{number = 4, name = (null)}

若是把新建的队列改成并行队列, 同步执行code

//并行队列
 dispatch_queue_t queue = dispatch_queue_create("testQueue", DISPATCH_QUEUE_CONCURRENT);
 dispatch_sync(queue, ^{
    NSLog(@"111");
    NSLog(@"111中 %@",[NSThread currentThread]);
});
dispatch_sync(queue, ^{
    NSLog(@"222");
    NSLog(@"222中 %@",[NSThread currentThread]);
});
dispatch_sync(queue, ^{
    NSLog(@"333");
    NSLog(@"333中 %@",[NSThread currentThread]);
});
dispatch_sync(queue, ^{
    NSLog(@"444");
    NSLog(@"444中 %@",[NSThread currentThread]);
});

结果

2018-03-09 16:31:50.498599+0800 Learning[3938:341075] 111
 2018-03-09 16:31:50.498836+0800 Learning[3938:341075] 111中 <NSThread: 
 0x600000063d80>{number = 1, name = main}
 2018-03-09 16:31:50.498946+0800 Learning[3938:341075] 222
 2018-03-09 16:31:50.499101+0800 Learning[3938:341075] 222中 <NSThread: 
 0x600000063d80>{number = 1, name = main}
 2018-03-09 16:31:50.499227+0800 Learning[3938:341075] 333
 2018-03-09 16:31:50.499353+0800 Learning[3938:341075] 333中 <NSThread: 
 0x600000063d80>{number = 1, name = main}
 2018-03-09 16:31:50.499461+0800 Learning[3938:341075] 444
 2018-03-09 16:31:50.499609+0800 Learning[3938:341075] 444中 <NSThread: 
 0x600000063d80>{number = 1, name = main}

把上面代码中的同步改成异步, 即并行队列, 异步执行

2018-03-09 16:34:13.089611+0800 Learning[3982:344351] 222
2018-03-09 16:34:13.089612+0800 Learning[3982:344350] 333
2018-03-09 16:34:13.089612+0800 Learning[3982:344349] 111
2018-03-09 16:34:13.089639+0800 Learning[3982:344352] 444
2018-03-09 16:34:13.089997+0800 Learning[3982:344350] 333中 <NSThread: 
0x60000027d680>{number = 3, name = (null)}
2018-03-09 16:34:13.089997+0800 Learning[3982:344349] 111中 <NSThread: 
0x604000271800>{number = 4, name = (null)}
2018-03-09 16:34:13.090004+0800 Learning[3982:344352] 444中 <NSThread: 
0x604000271440>{number = 6, name = (null)}
2018-03-09 16:34:13.090031+0800 Learning[3982:344351] 222中 <NSThread: 
0x604000271480>{number = 5, name = (null)}

从结果中能够看得出, 开启了四个不一样的现成来执行四个任务.

注意
在同步+串行的时候会有一个特殊的状况, 上面也提到了, 主队列也是一个串行队列, 若是当前在主线程中且把任务加到主队列中会如何呢 ?

NSLog(@"---前 %@",[NSThread currentThread]);
dispatch_sync(dispatch_get_main_queue(), ^{//dispatch_sync
    NSLog(@"---中 %@",[NSThread currentThread]);
});
NSLog(@"---后 %@",[NSThread currentThread]);

运行结果造成死锁.
思考: 一样都是串行队列, 为何任务添加到主队列会形成死锁现象, 新建一个串行队列则能够正常执行 ?
解释: 在执行完第一个NSLog的时候, 遇到dispatch_sync, 会暂时阻塞主线程. 那么咱们想一下, 在阻塞以前, 主线程正在执行的是主队列中的哪个任务呢? 用咱们实际的例子来解释, 咱们再写上面的代码的时候, 这部分的代码是包裹在一个另方法中的, 就像我本身写的demo, 这段代码就写在viewDidLoad里面, 由于viewDidLoad这些任务也是添加在主队列中的, 因此说阻塞主线程时, 主线程应该是处理的主队中 viewDidLoad这个任务.
咱们调用了dispatch_sync后向主队列中添加了新的任务, 也就是dispatch_sync后面block中的代码. 可是根据队列的FIFO规则, 新添加的block中的任务, 确定是要排在主队列的最后.
由于是使用的dispatch_sync同步, 因此说必需要等执行dispatch_sync的block中的代码才会返回, 才会继续执行ViewDidLoad中dispatch_sync这个方法下面的方法, 也就是代码中的第三个NSLog, 可是block中的任务被放在了主队列的底部, 他是不可能在viewDidLoad这个任务还没完成的时候就执行到的, 因此就造成了两个任务互相等待的状况, 也就是造成了死锁.
因此说这样看来,GCD造成死锁的缘由应该是是队列阻塞，而不是线程阻塞.

dispatch_group

解决先执行A和B, AB都执行完再执行C的这种状况.

dispatch_group_t group = dispatch_group_create();
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);
dispatch_group_async(group, queue, ^{
    // 1
    sleep(5);
    NSLog(@"task 1");
});

dispatch_group_async(group, queue, ^{
    //2
    NSLog(@"task 2");
});

dispatch_group_notify(group, queue, ^{
        NSLog(@"done ");
    });

或者

dispatch_group_t group = dispatch_group_create();
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);

dispatch_group_enter(group);
dispatch_async(queue, ^{
    NSLog(@"11");
    dispatch_group_leave(group);
});

dispatch_group_enter(group);
dispatch_async(queue, ^{
    sleep(7);
    NSLog(@"22");
dispatch_group_leave(group);
});

dispatch_group_enter(group);
dispatch_async(queue, ^{
    NSLog(@"33");
    dispatch_group_leave(group);
});

dispatch_group_notify(group, queue, ^{
    NSLog(@"done");
});

结果都是先执行完上面的在打印这个done, 这个不须要解释了.

有时候可能会碰到dispatch_group_wait, 注意一下, 由于他会阻塞线程, 因此不能放在主线程里面执行, 等待的时间是以group中任务开始执行的时间算起.

dispatch_barrier_async

多线程最多见的问题就是读写，好比数据库读写，文件读写，读取是共享的，写是互斥.

使用Concurrent Dispatch Queue和dispatch_barrier_basync函数可实现高效率的数据库访问和文件访问。
若是容许多个线程进行读操做，当写文件时，阻止队列中全部其余的线程进入，直到文件写完成.

在读取文件时, 直接使用dispatch_async异步读取, 当要写文件是, 使用dispatch_barrier_async. 用代码看一下dispatch_async和dispatch_barrier_async的执行顺序.

dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(queue, ^{
        NSLog(@"task 1");
    });

    dispatch_async(queue, ^{
        sleep(2);
        NSLog(@"task 2");
    });
    
    dispatch_barrier_async(queue, ^{
        NSLog(@"barrier -- ");
        sleep(3);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"task 3");
    });
    
    dispatch_async(queue, ^{
        NSLog(@"task 4");
    });
    
    NSLog(@" end ");

结果是先打印完task1和2, 在打印完barrier, 最后打印task3和4, 同理到文件读写中, 文件读取直接用dispatch_async, 写入使用dispatch_barrier_async, 则在写入文件时, 无论前面有多少操做都会等待前面的操做完成, 并且在写入的时候, 也没有其余线程访问, 从而达到线程安全.

1. iOS- GCD总结
2. GCD总结
3. GCD小总结
4. GCD和NSOperation总结
5. GCD学习
6. 学习：数学----gcd及扩展gcd
7. GCD基本使用总结
8. iOS ---GCD 总结篇章
9. iOS多线程：GCD总结
10. GCD 学习(四) dispatch_group
更多相关文章...
• XML 总结下一步学习什么呢？ - XML 教程
• 您已经学习了 XML Schema，下一步学习什么呢？ - XML Schema 教程
• Tomcat学习笔记（史上最全tomcat学习笔记）
• 适用于PHP初学者的学习线路和建议