GCD详解一

于 2018-07-27 10:05:16 发布
阅读量5.1k 收藏 1
点赞数 3
分类专栏： GCD 文章标签： GCD 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_34003239/article/details/81231444
版权

1个CPU执行的CPU命令列为一条无分叉路经，即为线程。一个物理CPU芯片实际上有64个（64核）CPU，如果一个CPU核虚拟为两个CPU核工作，那么一台计算机上使用多个CPU核就是理所当然的事。尽管如此，一个CPU核执行的CPU命令列仍为一条无分叉路经。这种无分叉路经只有一条，存在多条即为“多线程“。

使用多线程的缺点：多线程编程实际上是一种容易发生各种问题的编程技术比如多个线程更新相同的资源就会导致数据的不一致（数据竞争），停止等待时间的线程会导致多个线程相互之间持续等待（死锁），使用太多的线程会消耗大量的内存等。

优点：应用程序在启动时，通过最先执行的线程，即“主线程”来描绘UI，触摸屏幕等点击时间等如果在主线程中进行一些耗时操作，就会妨碍主线程的执行（阻塞），实际上就是妨碍主线程的runloop的主循环的执行，从而导致不能更新界面，应用程序的画面长时间停止等问题。如果开辟一条新的线程去执行耗时任务，待耗时任务之行结束后再由主线程去更新数据，将会得到很好的用户体验。

同步与异步的区别：主要看是否阻塞当前线程，同步操作会阻塞当前线程，而异步则不会。

队列：用于存放任务共有串行队列和并行队列。

串行队列：放到串行队列的任务，GCD会  FIFO（先进先出） 地取出来一个，执行一个，然后取下一个，这样一个一个的执行。

并行队列：放到并行队列的任务，GCD也会FIFO的取出来，但不同的是，它取出来一个就会放到别的线程，然后再取出来一个又放到另一个的线程这样由于取的动作很快，忽略不计，看起来，所有的任务都是一起执行的。不过需要注意，GCD会根据系统资源控制并行的数量，所以如果任务很多，它并不会让所有任务同时执行。

在很多人的多线程讲解中都会称并行队列为并发队列，然而两者之间具有很大的区别：

并发：当有多个线程在操作时，如果系统只有一个CPU，则它根本不可能真正同时进行一个以上的线程，它只能把CPU运行时间划分成若干个时间段，再将时间段分配给各个线程执行，在一个时间段的线程代码运行时，其它线程处于挂起状。这种方式我们称之为并发（并行）。

并行：当系统有一个以上的CPU时，则线程的操作有可能非并发当一个CPU执行一个线程时，另一个CPU可以执行另一个线程，两个线程互不抢占CPU资源，可以同时进行，这种方式我们称之为并行（并行）。

两个之间的区别：并发和并行是即相似又有区别的两个概念，并行是指两个或者多个事件在同一时刻发生;而并发是指两个或多个事件在同一时间间隔内发生。

主线程串行队列（main_queue）

当应用启动的时候，就有一个进程被操作系统创建，与此同时也会立即启动一个线程，这个线程就是主线程。负责所有的UI操作和刷新。

1.主线程串行队列同步执行队列（会产生死锁）

    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"%@",[NSThread currentThread]);
    });

2.主线程串行异步执行队列   

dispatch_async(dispatch_get_main_queue(), ^{
        NSLog(@"%@",[NSThread currentThread]);
    });

自定义队列（dispatch_queue_create）

1.创建队列

一个第参数用于DEBUG的时候标识唯一的队列，可以为空; 第二个参数用来表示创建的队列是串行的还是并行的，传入  DISPATCH_QUEUE_SERIAL  或  NULL  。表示创建串行队列传入  DISPATCH_QUEUE_CONCURRENT  表示创建并行队列。

并行队列：

dispatch_queue_t concurrent_queue = dispatch_queue_create("com.myThread.concurrent", DISPATCH_QUEUE_CONCURRENT);

串行队列：

dispatch_queue_t serial_queue = dispatch_queue_create("com.myThread.SERIAL",DISPATCH_QUEUE_SERIAL);

2.自定义并行队列

（1）执行同步并发任务

一个接一个的先进先出的进行执行，任务还是在主线程中进行执行

dispatch_queue_t concurrent_queue = dispatch_queue_create("com.myThread.concurrent", DISPATCH_QUEUE_CONCURRENT);

    dispatch_sync(concurrent_queue, ^{
        NSLog(@"test1");
    });

    dispatch_sync(concurrent_queue, ^{
        NSLog(@"test2");
    });

dispatch_sync(concurrent_queue, ^{
        NSLog(@"test3");
    });

输出结果：test1  test2  test3

（2）执行异步并行任务

异步执行也不绝对会另开线程（主线程异步派发任务到主线程）

        dispatch_queue_t concurrent_queue = dispatch_queue_create("com.myThread.concurrent", DISPATCH_QUEUE_CONCURRENT);

        dispatch_async(concurrent_queue, ^{
            NSLog(@"test1");
        });

        dispatch_async(concurrent_queue, ^{
            NSLog(@"test2");
        });

        dispatch_async(concurrent_queue, ^{
            NSLog(@"test3");
        });

输出结果：test3  test2  test1

（3）同步串行

为开辟新的线程，任务被派发到主线程进行执行

dispatch_queue_t serial_queue = dispatch_queue_create("com.myThread.serial", DISPATCH_QUEUE_SERIAL);

        dispatch_sync(serial_queue, ^{
            NSLog(@"test1");
            NSLog(@"%@",[NSThread currentThread]);
        });

        dispatch_sync(serial_queue, ^{
            NSLog(@"test2");
            NSLog(@"%@",[NSThread currentThread]);
        });

        dispatch_sync(serial_queue, ^{
            NSLog(@"test3");
            NSLog(@"%@",[NSThread currentThread]);
        });

输出结果：test1  test2  test3

（4）异步串行

异步串行虽然也会开辟线程，但是只会开辟一条新的线程，而且这条新开辟的线程会被反复使用。       

dispatch_queue_t serial_queue = dispatch_queue_create("com.myThread.serial", DISPATCH_QUEUE_SERIAL);

        dispatch_async(serial_queue, ^{
            NSLog(@"test1");
            NSLog(@"%@",[NSThread currentThread]);
        });

        dispatch_async(serial_queue, ^{
            NSLog(@"test2");
            NSLog(@"%@",[NSThread currentThread]);
        });

        dispatch_async(serial_queue, ^{
            NSLog(@"test3");
            NSLog(@"%@",[NSThread currentThread]);
        });

输出结果：test1  test2  test3

全局并行队列（dispatch_get_global_queue ）

创建全局并行队列

//默认优先级
dispatch_queue_t globalQueue1 = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); 

//高优先级
dispatch_queue_t globalQueue2 = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);

//低优先级
dispatch_queue_t globalQueue3 = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);  

//后台优先级
dispatch_queue_t globalQueue4 = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);

（1）全局同步并发队列

未开辟新的线程，会阻塞主线程任务    

 dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    dispatch_sync(queue, ^{
        NSLog(@"test1");
    });

    dispatch_sync(queue, ^{
        NSLog(@"test2");
        sleep(2);
        NSLog(@"test3");
    });

    NSLog(@"test4”);

输出结果：test1 test2   test3  test4  

（2）全局异步并行队列

开辟新的线程，不影响主线程任务的执行  

  dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    dispatch_async(queue, ^{
        NSLog(@"test1");
    });

    dispatch_async(queue, ^{
        NSLog(@"test2");
        sleep(2);
        NSLog(@"test3");
    });

    NSLog(@"test4");

输出结果：test2 test4   test1  test3

队列组（dispatch_group ）  

（1）队列组的管理机制类似于ARC自动引用计数模式，当添加一个任务（dispatch_group_async）它的计数加1，当块中的任务执行完成之后计数减1，当计数为0之后，进行通知（dispatch_group_notify）。   

dispatch_queue_t queue  = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    dispatch_group_t group = dispatch_group_create();

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

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

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

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

输出结果：test3 test2   test1  test4

（2）队列组也提供了类似于MRC的机制：  dispatch_group_enter （group）计数加1，dispatch_group_leave （group）计数减1，计数为零的时候进行通知。   

 dispatch_queue_t queue  = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    dispatch_group_t group = dispatch_group_create();

    for (int i=0; i<4; i++) {
        dispatch_group_enter(group);
        dispatch_group_async(group, queue, ^{
             NSLog(@"%d",i);
            dispatch_group_leave(group);
        });
    }

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

输出结果：1 2 3 4  test4

（3）线程阻塞的同步等待dispatch_group_wait   

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

    dispatch_group_async(group, queue, ^{

        long isExecuteOver = dispatch_group_wait(group, delayTime);

        if (isExecuteOver) {
            NSLog(@"wait over");
        } else {
            NSLog(@"not over");
        }
        NSLog(@"test2");
    });

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

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

输出结果：test1 test3等待test2 test4    

线程死锁探讨

示例一代码如下：  

  NSLog(@"test1");

    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"test2");
    });

    NSLog(@"test3");

输出完test1之后崩溃：线程1：EXC_BAD_INSTRUCTION（代码= EXC_I386_INVOP，子代码= 0x0）

原因解析：打印完TEST1后，dispatch_sync立即阻塞当前的主线程，然后把块中的任务放到main_queue中，可是main_queue中的任务会被取出来放到主线程中执行，但主线程这个时候已被被阻塞了，所以块中的任务就不能完成，它不完成，dispatch_sync就会一直阻塞主线程，这就是死锁现象。导致主线程一直卡死。 

示例二代码如下：   

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

    dispatch_async(queue, ^{
            NSLog(@"test1");
            NSLog(@"%@",queue);
            dispatch_sync(queue, ^{
                NSLog(@"test2");
            });
        });

  输出完test1和test2之后崩溃：线程1：EXC_BAD_INSTRUCTION（代码= EXC_I386_INVOP，子代码= 0x0）

`dispatch_async`异步执行，所以当前线程不会被阻塞，于是有了两条线程，一条当前线程继续往下打印出`之后 - ％@`这句，另一台执行Block中的内容打印`sync之前测试1的`这句。因为这两条是并行的，所以打印的先后顺序无所谓。

`dispatch_sync`同步执行，于是它所在的线程会被阻塞，一直等到`sync`里的任务执行完才会继续往下。于是`sync`就高兴的把自己座中的任务放到`队列中，可谁想``队列是一个串行队列，一次执行一个任务，所以`sync`的块必须等到前一个任务执行完毕，可万万没想到的是``队列正在执行的任务就是被``同步阻塞了的那个。于是又发生了死锁。所以`sync`所在的线程被卡死了。剩下的两句代码自然不会打印。

参考资料1：HTTPS：//www.jianshu.com/p/0b0d9b1f1f19

参考资料2：HTTPS：//www.jianshu.com/p/ae786a4cf3b1

下一篇：GCD详解二

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值