iOS学习笔记-----GCD 用法介绍

最新推荐文章于 2021-01-28 15:10:26 发布

Maybe_Chen

最新推荐文章于 2021-01-28 15:10:26 发布

阅读量382

点赞数

分类专栏： iOS学习笔记文章标签： gcd 多线程 c语言 OC NSThread

本文链接：https://blog.csdn.net/czzj0212/article/details/51581599

版权

iOS学习笔记专栏收录该内容

16 篇文章 0 订阅

订阅专栏

GCD(Grand Central Dispatch)

简介

Apple提供的一套更底层、更高效的并发编程技术,纯C语言、基于Block
支持同步或异步任务处理,串行、并行的处理队列,非系统调用的信号量机制,定时任务处理,进程、文件或网络的监听任务等

优点

易用:GCD比之thread更简单易用。基于block的特性导致它能极为简单得在不同代码作用域之间传递上下文
效率:GCD实现功能轻量、优雅,使得它在很多地方比之专门创建消耗资源的线程更实用且快速
性能:GCD自动根据系统负载来增减线程数量,这就减少了上下文切换以及增加了计算效率
安全:无需加锁或其他同步机制

Dispatch Queue

两种队列

Dispatch Queue是执行处理的等待队列。通过dispatch_async等函数, 按照先进先出(FIFO)顺序追加到Queue中处理,执行处理时,存在两种 Dispatch Queue:

Serial Dispatch Queue :

串行队列,一个线程同时执行一个任务,可以避免数据竞争的问题可以生成多个 Serial Dispatch Queue,各个 Serial Dispatch Queue 将并行执行
Concurrent Dispatch Queue :

并发队列,多个线程同时执行多个任务,效率高,具体是多少个线程并发执行,取决于CPU核数和CPU负荷

主队列与全局队列

Main Dispatch Queue

主队列,在主线程里执行的队列。因为主线程只有一个,所以 Main Dispatch Queue 自然就是 Serial Dispatch Queue. 一切跟UI有关的操作必须放在主线程中执行,所以要追加到Main Dispatch Queue. (dispatch_get_main_queue)
Global Dispatch Queue

全局队列,所有应用程序都能够使用的 Concurrent Dispatch Queue. (dispatch_get_global_queue)

GCD使用

1.两种任务添加方式

dispatch_async 异步添加

提交一个异步执行的 block块到队列里面并且直接返回,不用等待 block 被调用
dispatch_sync 同步添加

提交一个同步执行的 block块到队列里面并且等待,直到这个 block 执行完成,与 dispatch_async 相反注:使用 dispatch_sync 容易引起死锁,慎重使用。比如在主线程里面执行往主队列里面添加任务的操作就会引起死锁

2.使用GCD简单实现UIImageView异步加载图片

创建类目
自定义方法

- (void)setImageWithURL:(NSURL *)url {

    //创建串行队列
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);

    //依次将两个任务 异步的添加到串行队列中
    //局部变量 只有添加了__blcok 才能在block中被修改
    __block UIImage *image = nil;
    //开启多线程 加载网络图片
    dispatch_async(queue, ^{
        //从网络读取数据
        NSData *data = [NSData dataWithContentsOfURL:url];
        image = [UIImage imageWithData:data];
    });
    //回到主线程 显示图片到视图中
    dispatch_async(queue, ^{
        //重新获取主队列，并且将显示图片的操作，添加到主队列执行
        dispatch_queue_t mainQueue = dispatch_get_main_queue();
        //向主队列中添加界面刷新操作
        dispatch_async(mainQueue, ^{
            self.image = image;
        });

    });

}

3.延迟任务 dispatch_after


    /*  获取某一个时间点
     *  @param when    参照时间   DISPATCH_TIME_NOW = 当前时间点
     *  @param delta   时间差 纳秒为单位的时间  NSEC_PER_SEC = 1秒
     *  @return 时间点
     */
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC * 3);

//延时调用异步任务
dispatch_after(time, dispatch_get_main_queue(), ^{
        NSLog(@"延迟任务执行");
     });

dispatch_after 和 performSelector:withObject:afterDelay: 的区别

1. 调用方式，前者使用block形式来调用，后者只能使用Selector 2. 后者能够通过cancel来取消还未开始的方法掉用，但是dispatch_after需要通过非常复杂的方法才能够来取消延迟任务。 3. dispatch_after的精确度比后者高很多

4.设置队列优先级

dispatch_set_target_queue(<#dispatch_object_t object#>, <#dispatch_queue_t queue#>);
//改变queue的优先级与目标queue相同
//可以使多个serial queue在目标queue上 一次只有一个执行(串行执行)
/*
优先级
DISPATCH_QUEUE_PRIORITY_HIGH 2     高优先级
DISPATCH_QUEUE_PRIORITY_DEFAULT 0  默认优先级
DISPATCH_QUEUE_PRIORITY_LOW (-2)   低优先级
DISPATCH_QUEUE_PRIORITY_BACKGROUND 后台执行
*/

5.挂起队列

    //将队列处于悬停状态，在悬停状态的队列，无法继续执行其中的任务。但是对已经开始执行的任务，无效
    //创建串行队列
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);
    //挂起队列
    dispatch_suspend(queue);
    //在5秒钟之后 再进行恢复
    dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC * 5);
    dispatch_after(time, dispatch_get_main_queue(), ^{
       //恢复队列
        dispatch_resume(queue);
    });

挂起任务 dispatch_suspend

挂起(暂停)队列里面尚未开始执行的任务,对已经正在执行的任务没有影响使 queue 的 suspension reference count 加1
恢复任务 dispatch_resume
恢复队列里面之前被挂起的任务,使这些任务能够继续执行使 queue 的 suspension reference count 减1
注意事项
当suspension reference count大于0时,queue就保持挂起状态。因此,必须平衡使用suspend和resume 如果挂起了一个queue或者source,那么在销毁它之前,必须先对其进行恢复

6.一次任务

保证 dispatch_once 中的代码块在应用程序里面只执行一次,无论是不是多线程。

所以可以用来实现单例模式,安全、简洁、方便。

#import "Person.h"

@implementation Person
static Person *p;
+ (instancetype)sharedPerson {


    if (p == nil) {
        //dispatch_once 一次任务 多用于单例对象
        //使用dispatch_once执行的代码，在整个程序的运行过程中，一共只能执行一次
        //onceToken 表示执行的标记
        static dispatch_once_t onceToken;
        dispatch_once(&onceToken, ^{
            p = [[super allocWithZone:nil] init];
        });
    }

    return p;
}

+ (instancetype)allocWithZone:(struct _NSZone *)zone {
    if (p == nil) {
        p = [Person sharedPerson];
    }

    return p;
}

- (id)copy {
    return self;
}

@end

7.组任务

1.dispatch_group_async 监视一组block任务的完成,多个任务都结束后的一个汇总处理,可以同步或异步地监视 2.dispatch_group_notify 所有任务执行结束汇总,不阻塞当前线程 3.dispatch_group_wait 等待直到所有任务执行结束,中途不能取消,阻塞当前线程
具体代码:

    //创建队列
    dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    //创建任务组
    dispatch_group_t group = dispatch_group_create();

    //1.添加任务到队列中，并且添加到任务组中
    dispatch_group_async(group, globalQueue, ^{

        NSLog(@"任务1开始");
        [NSThread sleepForTimeInterval:3];
        NSLog(@"任务1结束");
    });


    //2.在组中所有的任务完成后，会收到一个完成的通知，然后来调用相对应的Block
    dispatch_group_notify(group, globalQueue, ^{
        NSLog(@"任务已经完成");
    });


    //3.监控任务是否完成
    //设定时间点
    dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC * 8);
    //等待  等待到某个时间点后，来查看任务的完成情况
    //等待操作，会堵塞当前线程
    //DISPATCH_TIME_FOREVER表示一直等待，直到所有任务都完成
    long result = dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
    //返回值为0  则代表所有任务完成，不为0 表示有任务没完成
    if (result == 0) {
        NSLog(@"所有任务已经执行完毕");
    } else {
        NSLog(@"还有任务没有完成,%li", result);
    }

8.多元调用(迭代)

1. dispatch_apply 提交一个多元调用的block块到队列里面,并且等待block任务的所有迭代,完成之后才返回. 2. dispatch_apply 会阻塞当前线程,推荐在 dispatch_async 中执行 dispatch_apply 函数. 3. 结合concurrent queue,dispatch_apply能实现一个高性能的循环迭代.

    NSMutableArray *array = [NSMutableArray arrayWithCapacity:1000];
     for (int i = 0; i < 1000; i++) {
        [array addObject:@(i)];
    }
    //多元调用（迭代）
    //创建并发队列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    //在全局队列中 异步的添加迭代任务
    dispatch_async(queue, ^{

        //多元调用
        /**
         *  多元调用 每一次调用之间没有顺序
         *
         *  @param iterations   调用次数
         *  @param queue        调用所在队列  并发队列
         *  @param block        每一次调用 所执行的Block
         *
         */
        dispatch_apply(array.count, queue, ^(size_t index) {
            [NSThread sleepForTimeInterval:0.3];
            NSLog(@"%@", array[index]);
            NSLog(@"%@", [NSThread currentThread]);
        });

    });


    /*
     为了提高大数据量的数组遍历的速度，所以使用多元调用
     for循环遍历，每一次遍历操作，串行执行。总时间 ＝ 每一次遍历的耗时 ＊ 总次数
     使用多元调用，将每一次遍历，放到多线程中去。在多线程中，可以同时遍历多次，这样能够提高遍历的效率
     总时间 ＝ 每一次遍历的耗时 ＊ 总次数 ／ 线程数 ＋ 线程开启关闭的时间

     !!  遍历的过程，没有顺序不按照数组顺序来
     */

9.设立障碍

1.dispatch_barrier_async 提交一个异步执行的带障碍的block块到队列里面,并且直接返回. 2.使用 dispatch_barrier_async,需要指定通过dispatch_queue_create函数创建的一个concurrent queue. 3.在barrier任务之前的所有任务将并行执行,任何在此之后提交的任务将不会执行直到这个 barrier任务执行完成.

 //添加障碍任务
    //创建并发队列 不能使用全局队列
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);

    //异步的添加任务1
    dispatch_async(queue, ^{
        for (int i = 0; i < 10; i++) {
            NSLog(@"任务1 %i", i);
        }
    });

 //异步的添加任务2
  dispatch_async(queue, ^{
        for (int i = 0; i < 10; i++) {
            NSLog(@"任务2 %i", i);
        }
    });
 //插入障碍任务
    dispatch_barrier_async(queue, ^{
        NSLog(@"障碍任务开始");
        [NSThread sleepForTimeInterval:3];
        NSLog(@"障碍任务结束");
    });

 //异步的添加任务3
    dispatch_async(queue, ^{
        for (int i = 0; i < 10; i++) {
            NSLog(@"任务3 %i", i);
        }
    });

 //异步的添加任务4
    dispatch_async(queue, ^{
        for (int i = 0; i < 10; i++) {
            NSLog(@"任务4 %i", i);
        }
    });


//任务1,2执行完成后,要执行障碍任务,等待障碍任务完成,才能继续执行任务3,4.

这里写图片描述

10.信号量semaphore

1.dispatch_semaphore_t持有计数的信号,使用计数来实现该信号功能。计数为0时等待,计数大于等于1时, 减去1而不等待 2.dispatch_semaphore_create 创建新的计数信号 3.dispatch_semaphore_wait 信号量为0时等待,大于等于1时,减1而不等待 4.dispatch_semaphore_signal 发信号,使信号加1

//使用信号量 来设置同时访问资源的线程数
    //创建队列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    __block NSMutableArray *array = [[NSMutableArray alloc] init];
    //创建信号量
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);

    //循环插入数据
    for (int i = 0; i < 100000; i++) {
        dispatch_async(queue, ^{

            /**
             * 判断信号量 是否能够继续执行 访问公共资源
             * 如果此时信号量不为0  则信号量减1，然后继续执行代码
             * 信号量为0 则等待，直到时间超时或者信号量大于0
             * 保证信号量为0时,其他线程不能访问
             */
            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

            [array addObject:@(i)];

            //公共资源访问完毕，释放信号量
            dispatch_semaphore_signal(semaphore);
        });
    }

多线程总结

GCD pk NSOperationQueue

GCD是纯C语言的API;NSOperationQueue是基于GCD的OC版本的封装
GCD的执行速度比NSOperationQueue快
GCD只支持FIFO的队列,且任务一旦添加到队列则无法取消;NSOperationQueue 可以很方便的调整执行顺序,可以添加依赖,设置最大并发量
NSOperationQueue支持KVO,可以检测Operation的状态(执行、结束、取消)

GCD or NSOperationQueue

GCD本身非常简单、易用、效率高,对于不复杂的多线程操作,会节省代码量,而Block参数的使用,会是代码更为易读,建议在简单项目中使用
NSOperation是对线程的高度抽象,在项目中使用它,会使项目的程序结构更好,子类化NSOperation的设计思路,是具有面向对象的优点(复用、封装),使得实现是多线程支持,而接口简单,建议在复杂项目中使用

Sleep和Wait的区别

1.sleep是NSThread中的一个方法,wait是线程锁中的一个方法.
2.sleep用于线程控制,使某一个线程进入到休眠状态.wait用于线程通信,使一个线程进入到等待状态,但是当另一个线程解锁时,会唤醒当前等待的线程.
3.sleep不会释放线程,在休眠状态中,会一直占用当前线程.wait会释放当前线程,将线程空闲出来.当wait被唤醒时,会重新获取线程的控制权.

Maybe_Chen

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
iOS学习笔记-----GCD 用法介绍

GCD(Grand Central Dispatch)简介Apple提供的一套更底层、更高效的并发编程技术,纯C语言、基于Block 支持同步或异步任务处理,串行、并行的处理队列,非系统调用的信号量机制,定时任务处理,进程、文件或网络的监听任务等优点易用:GCD比之thread更简单易用。基于block的特性导致它能极为简单得在不同代码作用域之间传递上下文效率:GCD实现功能轻量、优雅
复制链接

扫一扫