2021--- GCD

作者: 世玉茹花 | 来源:发表于2021-05-26 11:09 被阅读0次

gcd同步，异步，串行队列，并发队列，全局队列，主队列，以及死锁。

1、gcd队列阻塞问题[https://www.jianshu.com/p/1326e3fe24bf]

dispatch_queue_t mainQueue = dispatch_get_main_queue();
dispatch_sync(mainQueue, ^{
    NSLog(@"为啥堵塞");
});
阻塞，崩溃
[这样 按钮 方法和第一个任务就开始了互相等待，形成了死锁。]
主队列：app告诉主线程去打印个东西，但是你不能走，你得去完成后才能走。

dispatch_queue_t queue = dispatch_queue_create("abc", DISPATCH_QUEUE_SERIAL);
dispatch_sync(queue, ^{
    NSLog(@"为啥不堵塞");
});
不阻塞，执行代码
串行队列：app告诉主线程，您叫 ‘’‘abc’‘’去打印机上，打印个东西，但是你不能离开这里，任务完成后才能走。主线程告诉‘’‘abc’‘’，快去打印个东西，现在就要。

2、同步串行队列

没有开启新线程，所有操作都在当前线程按顺序执行。
1,2,3

3、同步并发队列

各个任务在同一个线程中执行（主线程或者子线程中）
1,2,3

4、异步串行队列

开启了新的线程，但是不管任务多少个，异步执行+同一条串行队列只开启一个新的线程，任务执行顺序也是按照队列顺序执行的，因为同一条线程中，必须等到前一个任务执行完毕，才能执行下一个任务。1,2,3

5、异步并发队列

开启了不同的线程，岂可任务完成顺序也是随机的，但是线程不会无限开启。（还要根据当前内存使用情况以及线程池线程数等因素）
2,3,1

6、异步主队列

异步执行加主队列不会开启新线程，任务都是在主线程执行的。
顺序执行:1,2,3

7、同步主队列

队列阻塞，直接崩溃。

8、死锁

产生死锁的四个必要条件：

（1）互斥条件：一个资源每次只能被一个进程使用。
（2）请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
（3）不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
（4）循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

同步-主队列：
由于同步任务，A必须等待B执行完毕才能执行；
但是由于主队列已经有A，所以必须等A执行完，才能把B放进主线程执行。

GCD任务执行顺序

1、串行队列先异步后同步

dispatch_queue_t serialQueue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
       
       NSLog(@"1");
       
       dispatch_async(serialQueue, ^{
           
            NSLog(@"2");
           
       });
       
       NSLog(@"3");
       
       dispatch_sync(serialQueue, ^{
           
           NSLog(@"4")；
       });
      NSLog(@"5");
输出：1，3，2，4，5

同步嵌套异步可以执行，
异步嵌套同步会崩溃

2、serial sync 执行

同步会阻塞主线程去执行队列中的任务。

dispatch_queue_t queue = dispatch_queue_create("----", DISPATCH_QUEUE_SERIAL);
    
    dispatch_sync(queue, ^{
        //打印 NSThread为main
        NSLog(@"开始----%@",[NSThread currentThread]);
        sleep(2);
        NSLog(@"结束----%@",[NSThread currentThread]);
    });
    NSLog(@"0000");
输出：开始，结束，000

3、serial sync 任务中嵌套 sync 任务【串行--同步嵌套同步】

  dispatch_queue_t queue = dispatch_queue_create("----", DISPATCH_QUEUE_SERIAL);
    
    dispatch_sync(queue, ^{
        //打印 NSThread为main
        NSLog(@"开始----%@",[NSThread currentThread]);
        dispatch_sync(queue, ^{
            NSLog(@"111----%@",[NSThread currentThread]);
        });
        NSLog(@"结束----%@",[NSThread currentThread]);
    });
    NSLog(@"0000");
输出：开始----
【发生线程死锁】根据串行队列任务是一个一个执行，同步执行会阻塞线程，当执行到第二个asyn任务时，它会阻塞线程去等待一个sync任务先执行完毕，而第二个任务又出现在第一个任务里，只有第二个执行完毕才能继续执行接下来的代码。双方卡住，造成死锁。

4、serial sync 任务中嵌套 async 任务【串行--同步嵌套异步】

dispatch_queue_t queue = dispatch_queue_create("----", DISPATCH_QUEUE_SERIAL);

    dispatch_sync(queue, ^{
        //打印 NSThread为main
        NSLog(@"开始----%@",[NSThread currentThread]);
        dispatch_async(queue, ^{
            NSLog(@"111----%@",[NSThread currentThread]);
        });
        sleep(2);
        NSLog(@"结束----%@",[NSThread currentThread]);
    });
输出：开始--main，，结束--main，，111---
分析：串行任务依次执行，当执行到async时需要等当前任务执行完成才会去执行里面的任务，因为是异步不会阻塞线程，且不是在主队列中所以会开启子线程执行，综上不会造成死锁。

5、serial async 任务中嵌套 sync【串行--异步嵌套同步】

dispatch_queue_t queue = dispatch_queue_create("----", DISPATCH_QUEUE_SERIAL);

    dispatch_async(queue, ^{
        //打印 NSThread为main
        NSLog(@"开始----%@",[NSThread currentThread]);
        dispatch_sync(queue, ^{
            NSLog(@"111----%@",[NSThread currentThread]);
        });
        NSLog(@"结束----%@",[NSThread currentThread]);
    });
    NSLog(@"0000");
输出：0000，，，，开始---，
分析：异步不阻塞当先线程，会先执行0000，然后执行async代码块，异步嵌套同步**依然会崩溃**。串行队列上任务一个个执行，上一个执行不完成，下一个任务就不会执行，而sync属于任务嵌套中的任务。

6、serial async 任务中嵌套 async【串行--异步嵌套异步】

dispatch_queue_t queue = dispatch_queue_create("----", DISPATCH_QUEUE_SERIAL);

    dispatch_async(queue, ^{
        //打印 NSThread为main
        NSLog(@"开始----%@",[NSThread currentThread]);
        dispatch_async(queue, ^{
            NSLog(@"111----%@",[NSThread currentThread]);
        });
        sleep(2);
        NSLog(@"结束----%@",[NSThread currentThread]);
    });
输出：开始---，结束，，，，1111，，，
分析：串行队列，任务依次执行，异步不会阻塞当前线程，具备开启线程能力，所以第二个async会等当前任务执行完毕再去执行。

7、concurrent sync【并发--同步】

dispatch_queue_t queue = dispatch_queue_create("----", DISPATCH_QUEUE_CONCURRENT);

    dispatch_sync(queue, ^{
        //打印 NSThread为main
        NSLog(@"开始----%@",[NSThread currentThread]);
        sleep(2);
        NSLog(@"结束----%@",[NSThread currentThread]);
    });
NSLog(@"0000");
输出：开始---，结束，，，，0000，，，
分析：并发队列多个任务可以同时执行，同步不具有开启线程能力，会阻塞当前线程。

8、concurrent sync 任务中嵌套 sync【并发--同步嵌套同步】

dispatch_queue_t queue = dispatch_queue_create("----", DISPATCH_QUEUE_CONCURRENT);

    dispatch_sync(queue, ^{
        //打印 NSThread为main
        NSLog(@"开始----%@",[NSThread currentThread]);
        dispatch_sync(queue, ^{
            NSLog(@"111----%@",[NSThread currentThread]);
        });
        sleep(2);
        NSLog(@"结束----%@",[NSThread currentThread]);
    });
输出：开始---，111---，结束---
分析：串行队列必然死锁，并发不会。
1.执行第一个sync，阻塞主线程，暂停正在执行的任务，转而执行sync里的任务；
2.执行到第二个sync，串行队列会相互等待，并发不会，新任务不必等待之前任务完成；所以第二个sync会暂停当前任务，去执行自己block里的任务。

9、concurrent sync 任务中嵌套 async【并发--同步嵌套异步】

dispatch_queue_t queue = dispatch_queue_create("----", DISPATCH_QUEUE_CONCURRENT);
dispatch_sync(queue, ^{
        //打印 NSThread为main
        NSLog(@"开始----%@",[NSThread currentThread]);
        dispatch_async(queue, ^{
            NSLog(@"111----%@",[NSThread currentThread]);
            sleep(1);
        });
        sleep(2);
        NSLog(@"结束----%@",[NSThread currentThread]);
    });
输出：开始---，111---，结束---
分析：sync阻塞线程执行任务，打印开始，async并发队列开启子线程执行新任务，不阻塞当前线程，但是sleep2比sleep1多了一秒。两个任务同时执行，111优先打印，然后打印结束。

10、concurrent async【并发--异步】

    dispatch_queue_t queue = dispatch_queue_create("----", DISPATCH_QUEUE_CONCURRENT);

    dispatch_async(queue, ^{
        
        //打印 NSThread为main
        NSLog(@"开始----%@",[NSThread currentThread]);
        sleep(2);
        NSLog(@"结束----%@",[NSThread currentThread]);
    });
    NSLog(@"0000");
输出：0000，，，开始---，结束----，
分析：异步开启子线程

11、concurrent async 任务中嵌套 sync【并发--异步嵌套同步】

dispatch_async(queue, ^{
        
        //打印 NSThread为main
        NSLog(@"开始----%@",[NSThread currentThread]);
        dispatch_sync(queue, ^{
            NSLog(@"111----%@",[NSThread currentThread]);
            sleep(1);
        });
        sleep(2);
        NSLog(@"结束----%@",[NSThread currentThread]);
    });
输出：开始---，111---，结束----，
分析：async开启子线程，sync阻塞线程，去执行自己的任务

12、concurrent async 任务中嵌套 async【并发--异步嵌套异步】

dispatch_async(queue, ^{
        
        //打印 NSThread为main
        NSLog(@"开始----%@",[NSThread currentThread]);
        dispatch_async(queue, ^{
            NSLog(@"111----%@",[NSThread currentThread]);
            sleep(1);
        });
        sleep(2);
        NSLog(@"结束----%@",[NSThread currentThread]);
    });
输出：开始---，结束----，111---，
分析：
1.执行到第一个async，因为并发，开启新线程去执行任务；
2.执行第二个async，又开启新的线程执行新的任务。

performselector

1、

dispatch_async(dispatch_get_global_queue(0, 0), ^{
        [self performSelector:@selector(test) withObject:nil];
    });
输出：test

2、

 dispatch_async(dispatch_get_global_queue(0, 0), ^{
        [self performSelector:@selector(test) withObject:nil afterDelay:1];
    });
输出：无

3、

dispatch_async(dispatch_get_global_queue(0, 0), ^{
        [self performSelectorInBackground:@selector(test) withObject:nil];
    });
输出：test

4、

dispatch_async(dispatch_get_global_queue(0, 0), ^{
        [self performSelector:@selector(test) onThread:[NSThread mainThread] withObject:nil waitUntilDone:NO];
    });
thread设置为主线程[NSThread mainThread]：输出test
thread设置为子线程[NSThread currentThread]：输出无

5、

    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        [self performSelector:@selector(test) withObject:nil afterDelay:1];
        [[NSRunLoop currentRunLoop]run];
    });
输出：test
这种方法创建任务提交到runloop上，gcd底层创建的线程是没有开启runloop的，所以这个方法会失效。