GCD

一，GCD哪些情况会创建线程，哪些情况不创建线程？

结论：
1，同步任务不论是串行队列还是并发队列都不会创建线程，都会在调用它的线程执行。
2，异步任务串行队列会创建一个线程，并顺序执行。
3，异步任务并发队列会创建多个线程，循序不定的执行。

下面是测试代码：

NSLog(@"================%@",[NSThread currentThread]);
        for (int i = 0; i < 10; i++) {
            dispatch_sync(dispatch_get_global_queue(0, 0), ^{
                NSLog(@"同步并发队列：dispatch_sync_dispatch_get_global_queue:%@",[NSThread currentThread]);
            });
        }
        
        NSLog(@"=====================");
        dispatch_queue_t serial = dispatch_queue_create("lable1", DISPATCH_QUEUE_SERIAL);
        for (int i = 0; i < 10; i++) {
            dispatch_sync(serial, ^{
                NSLog(@"同步串行队列：dispatch_sync_serial:%@",[NSThread currentThread]);
            });
        }
        
        NSLog(@"=======================");
        
        dispatch_queue_t serial2 = dispatch_queue_create("lable2", DISPATCH_QUEUE_SERIAL);
        for (int i = 0; i < 10; i++) {
            dispatch_async(serial2, ^{
                NSLog(@"异步串行队列：dispatch_async_serial:%@",[NSThread currentThread]);
            });
        }
        
        NSLog(@"=======================");
        
        for (int i = 0; i < 10; i++) {
            dispatch_async(dispatch_get_global_queue(0, 0), ^{
                NSLog(@"异步并发队列：dispatch_async_serial:%@",[NSThread currentThread]);
            });
        }

二,GCD

同步异步是相对函数而言的，串行和并发是相对队列而言的，任务在队列中开始执行都是按顺序执行的。

异步并发队列(队列可能是自己创建也可以是获取的全局并发队列):具备开线程的能力(可能会有多个线程，看任务的量和核数)，执行完成的顺序可能不同。

异步串行队列(队列可能是主队列也可以是创建的队列):在在主队列中执行则不会开线程，主队列是串行队列，并且绑定了只能在主线程中执行；如果是在自己创建的队列中执行，则可能开一个子线程执行队列中的任务。

同步并发队列:不会开子线程

同步串行队列:这里要分在创建的队列还是主队列，还有就是调用这个gcd函数是的线程有关.

更新：

同步异步是对任务而言的，异步任务会开启新线程，同步任务不会

并行串行是相对队列而言的，并行代表会同时执行多个任务，串行是执行完了一个才执行队列中的下一个。

栅栏在使用时，最好是在自定义的并发队列中使用，如果是串行队列就没有必要，但是如果是全局并发队列，那么有可能其他任务也在这个队列中，使用栅栏可能阻止了其他任务的执行。

在并发队列中，如果要在队列中所有任务完成后执行任务，那么就需要用到dispatch_group_t 的dispatch_group_notify通知队列的任务已经完成

dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t queue = dispatch_queue_create("com.gcd-group.www", DISPATCH_QUEUE_CONCURRENT);
    dispatch_group_async(group, queue, ^{
        for (int i = 0; i < 1000; i++) {
            if (i == 999) {
                NSLog(@"11111111");
            }
        }
    });

    dispatch_group_async(group, queue, ^{
        NSLog(@"22222222");
    });

    dispatch_group_async(group, queue, ^{
        NSLog(@"33333333");
    });

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

swift中用notify不能实现效果，很奇怪
用wait能够实现效果，但只能监听前面的异步方法，代码如下：

let queue1 = DispatchQueue.global()
        let group = DispatchGroup()
        let current1 = Thread.current
        print("curreThread\(current1)")

        queue1.async(group: group, qos: .default, flags: []) {
            for _ in 0..<1000 {
                let current1 = Thread.current
                print("=====================1\(current1)")
            }
        }
      
        queue1.async(group: group, qos: .default, flags: []) {
            for _ in 0..<1000 {
                print("=====================2")
            }
        }
        
        queue1.async(group: group, qos: .default, flags: []) {
            for _ in 0..<1000 {
                print("=====================3")
            }

        }
        

        let result = group.wait(timeout: .now() + 0.001)
        switch result {
        case .success:
            print("============not time out")
        case .timedOut:
            print("============time out")
        }

dispatch_apply的使用

dispatch_apply中添加任务到队列中执行，执行完后才会执行后面的代码：

dispatch_queue_t globle_queue = dispatch_get_global_queue(0, 0);
    dispatch_queue_t serial_queue = dispatch_queue_create("serlize", DISPATCH_QUEUE_SERIAL);
//串行队列的
    dispatch_apply(10, serial_queue, ^(size_t index) {
        
        NSLog(@"111%d===%@",index,[NSThread currentThread]);
        
    });
    
    dispatch_apply(10, globle_queue, ^(size_t index) {
        
        NSLog(@"222%d===%@",index,[NSThread currentThread]);
        
    });
    
    NSLog(@"done");

执行过程是先执行串行10个队列的apply任务，然后执行并发队列的10个任务，最后执行打印done的任务。
另外，在串行队列中的任务在主线程中执行，没有开启新的线程。在并发队列上的apply任务开启了多个新的线程（包括执行的主线程）。

三，任务和队列的关系

1,在串行队列上执行异步任务，会新开启线程，串行完成。比如：

- (void)testOnThread {
    dispatch_async(_serialQueue, ^{
        for (NSInteger i = 0; i < 100; i++) {
            NSLog(@"getname%ld:%@",i,[NSThread currentThread]);
        }
    });
}

- (void)testMain {
    dispatch_async(_serialQueue, ^{
        for (NSInteger i = 0; i < 100; i++) {
            NSLog(@"testmain%ld:%@",i,[NSThread currentThread]);
        }
    });
}

如果testOnThread在thread2上调用,testMain在主线程中调用，且testOnThread先调用，那么testOnThread执行完成后，testMain才开始执行,并且内部执行的代码会重新开启线程执行，且在同一个线程上执行。

2,如果是在并发队列上，执行同步任务，那么不会开启线程，但执行顺序不一定：

- (void)testOnThread {
    dispatch_sync(_concurrentQueue, ^{
        for (NSInteger i = 0; i < 100; i++) {
            NSLog(@"getname%ld:%@",i,[NSThread currentThread]);
        }
    });
}

- (void)testMain {
    dispatch_sync(_concurrentQueue, ^{
        for (NSInteger i = 0; i < 100; i++) {
            NSLog(@"testmain%ld:%@",i,[NSThread currentThread]);
        }
    });
}

同上，testOnThread在thread2上调用,testMain在主线程中调用，且testOnThread先调用，队列是串行队列。那么，testMain方法中的打印不会等到testOnThread执行完成，会交错出现。但是其中执行的线程，分别是thread2和主线程，说明同步执行没有创建队列。

对于属性的setter和getter方法的线程同步，通过GCD来同步时，常用的做法是，setter方法通过异步并发队列执行，getter方法通过异步队列上的栅栏来做，这样就可以保证高效的写入，也可以同步读取。因为栅栏必须要在该并发队列上的任务执行完成后才会执行。

四，Dispatch Group

Dispatch Group中的任务执行完成后，有两种方式获取执行完成的消息：
1,阻塞等待: long dispatch_group_wait(group,timeout); //如果没有超时，那么返回0，超时，就返回非0值
2,异步通知: void dispatch_group_notify(group, queue,block); //接收一个block
注意：dispatch_group_wait超时的时间一般设置为DISPATCH_TIME_FOREVER。
dispatch_group_notify回调的线程，如果在调用的线程是主线程，回调的线程是主队列的话dispatch_group_notify不会有回调。（命令行会有这个问题，但是在iOS项目中没有这个问题）

- (void)test {
    group = dispatch_group_create();
    serialqueue = dispatch_queue_create("test_serial", DISPATCH_QUEUE_SERIAL);
    concurrentqueue = dispatch_queue_create("test_concurrent", DISPATCH_QUEUE_CONCURRENT);
   
    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        for (NSInteger i = 0; i < 10; i++) {
            NSLog(@"=======%@",[NSThread currentThread]);
        }
    });
    
    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        for (NSInteger i = 0; i < 10; i++) {
            NSLog(@"------%@",[NSThread currentThread]);
        }
    });
    
    long result = dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
    NSLog(@"执行结束了:%ld",result);
    dispatch_group_notify(group, concurrentqueue, ^{
        NSLog(@"执行结束的通知:%@",[NSThread currentThread]);
    });
//异步通知返回
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
            NSLog(@"执行结束的通知:%@",[NSThread currentThread]);
        });
//if ([NSThread currentThread].isMainThread) 

//同步等待返回
        long result = dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
        if (result) {
            
        }
}

五，主队列中一定是主线程，但主线程不一定只是在主队列中，也可能在其他的并发队列中执行.

- (void)test {
    dispatch_queue_t serial = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(serial, ^{
        for (NSInteger i = 0; i < 100; i++) {
            NSLog(@"====111:%@",[NSThread currentThread]);
        }
    });
    
    dispatch_sync(serial, ^{
        NSLog(@"-----------------------:%@",[NSThread currentThread]);
    });
    dispatch_async(serial, ^{
        for (NSInteger i = 0; i < 100; i++) {
            NSLog(@"====222:%@",[NSThread currentThread]);
        }
    });

    dispatch_sync(serial, ^{
        NSLog(@"执行结束了========:%@",[NSThread currentThread]);
    });
    
}

打印结果:
2018-08-06 18:07:50.280824+0800 powercontrol[29380:6052506] -----------------------:{number = 1, name = main}
2018-08-06 18:07:50.281018+0800 powercontrol[29380:6052506] 执行结束了========:{number = 1, name = main}
2018-08-06 18:07:50.281553+0800 powercontrol[29380:6052650] ====111:{number = 4, name = (null)}
2018-08-06 18:07:50.281783+0800 powercontrol[29380:6052650] ====111:{number = 4, name = (null)}
2018-08-06 18:07:50.281910+0800 powercontrol[29380:6052650] ====111:{number = 4, name = (null)}
可以看到在并发队列中，同步执行打印的线程是主线程

六，dispatch串行队列同步任务的死锁

出现死锁的情况是，调用串行队列上的同步任务时，外层有相同的串行队列执行了同步任务，这是场景。比如主线程中，执行了主队列上的同步任务：

NSLog(@"1111:%@",[NSThread currentThread]);
//外层是主队列
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"2222");  //任务2
    });
NSLog(@"3333"); //任务3

重点来了：看了晚上好多关于这种现象的解释，有些说是主线程阻塞了，有的说是任务2和任务3阻塞了线程。这些说法都不清楚，且经测试都是错误的。真正造成死锁的原因是内层函数和外层函数在相同队列相同线程上执行同步事件。真正的问题是外部有串行队列，调用了同步任务，内部有相同的串行队列，执行了同步任务，并且在同一个线程上，那么就会阻塞。阻塞的逻辑是：dispatch_sync是一个函数，外部添加的任务是同步的，执行完成才会执行内部的block同步任务，但是外部的任务就是执行内部的block任务，内部的任务得不到执行，外部的dispatch_sync任务也就得不到返回，这样就行程了死锁。再次总结是相同串行队列上的同步任务，在相同线程上内外分别执行，结论就是这个，下面是例证

1,死锁的不只是相同的线程

下面的例子中可以看出，222打印看出通过异步执行创建了一个新线程number为2，内部的333和444都是在这个线程上的同步任务，队列是不同的串行队列，但没有发生死锁的情况，说明死锁的原因不仅仅是线程阻塞。

NSLog(@"1111:%@===%@",[NSThread currentThread],dispatch_get_current_queue());
    _serialQueue = dispatch_queue_create("test", NULL);
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"2222:%@===%@",[NSThread currentThread],dispatch_get_current_queue());
        dispatch_sync(_serialQueue, ^{
            NSLog(@"3333:%@",[NSThread currentThread]);
            dispatch_sync(dispatch_queue_create("hahah", NULL), ^{
                NSLog(@"4444:%@",[NSThread currentThread]);
            });
        });

    });
    
    NSLog(@"5555");

//打印结果
2222:{number = 2, name = (null)}===
3333:{number = 2, name = (null)}
4444:{number = 2, name = (null)}

如果将333，444任务的队列换成相同的串行队列，那么就会出现444这个任务无法执行的情况。

_serialQueue = dispatch_queue_create("test", NULL);
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"2222:%@===%@",[NSThread currentThread],dispatch_get_current_queue());
        dispatch_sync(_serialQueue, ^{
            NSLog(@"3333:%@",[NSThread currentThread]);
            dispatch_sync(_serialQueue, ^{
                NSLog(@"4444:%@",[NSThread currentThread]);
            });
        });
    });
    NSLog(@"5555");
//打印结果
2222:{number = 3, name = (null)}===
3333:{number = 3, name = (null)}

从打印结果可以看出，发生阻塞的原因不是相同的线程添加了同步任务到串行队列中，而是将同步任务添加到了相同的串行队列中。

2，死锁的也不只是因为相同的队列

下面的代码是不会死锁的，尽管内外都有相同的串行队列，并且执行的都是同步事件，因为他们在不同的线程上。

_serialQueue = dispatch_queue_create("test", NULL);
    dispatch_sync(_serialQueue, ^{
        NSLog(@"000:%@",[NSThread currentThread]);
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            NSLog(@"111:%@",[NSThread currentThread]);
            dispatch_sync(_serialQueue, ^{
                NSLog(@"222:%@",[NSThread currentThread]);
            });
        });
    });

然后回归到开头的例子当中，为什么主线程中，调用主队列上的同步任务会出现死锁的现象呢？这个问题就很好回答了，因为外部的主线程的所在的队列是主队列，主队列是串行队列(尽管主线程也可以在其他队列中执行，测试可以用已经废弃的dispatch_get_current_queue()函数)，下面的代码相当于内部的主队列上的同步任务。也就是在主队列上调用了一个dispatch_sync同步任务，这个任务中执行的是需要同步完成的block，block因为在dispatch_sync之后添加到队列中，所以得不到执行。那么dispatch_sync就不会有返回，这样就形成了死锁。

//外部其实是主队列
dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"2222");  //任务2
    });