iOS-基础巩固-GCD

Grand Central Dispatch

GCD中有2个核心概念
任务：执行什么操作
队列：用来存放任务

将任务添加到队列中
GCD会自动将队列中的任务取出，放到对应的线程中执行
任务的取出遵循队列的FIFO原则：先进先出，后进后出

GCD中有2个用来执行任务的常用函数
queue：队列
block：任务
用同步的方式执行任务
dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);
用异步的方式执行任务
dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

有4个术语比较容易混淆：同步、异步、并发、串行
同步和异步主要影响：能不能开启新的线程
同步：只是在当前线程中执行任务，不具备开启新线程的能力
异步：可以在新的线程中执行任务，具备开启新线程的能力

并发和串行主要影响：任务的执行方式
并发：允许多个任务并发（同时）执行
串行：一个任务执行完毕后，再执行下一个任务
小结:
- 开不开线程,取决于执行任务的函数,同步不开,异步才能开
- 开几条线程,取决于队列,串行开一条,并发可以开多条(异步)

执行效果

基础函数

//dispatch_queue_create(const char *label,   // 队列名称
//                      dispatch_queue_attr_t attr);     // 队列的类型

//串行同步
    /**
     1.队列名称: 可以为 0
     2.队列的属性: DISPATCH_QUEUE_SERIAL == NULL 表示示串行!
     */
    dispatch_queue_t q = dispatch_queue_create("Thread A", NULL);
    
    //2.同步执行任务
    dispatch_sync(q, ^{
        NSLog(@"%@", [NSThread currentThread]);
    });

//并发异步
    dispatch_queue_t q = dispatch_queue_create("Thread B", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(q, ^{
        NSLog(@"%@ %d",[NSThread currentThread],i);
    });

//    GCD默认已经提供了全局的并发队列，供整个应用使用，可以无需手动创建
    
    dispatch_queue_t dispatch_get_global_queue(
                     dispatch_queue_priority_t priority,
                     unsigned long flags);
    /* 参数
     1. 涉及到系统适配
     iOS 8   服务质量
     QOS_CLASS_USER_INTERACTIVE    用户交互(希望线程快速被执行,不要用好使的操作)
     QOS_CLASS_USER_INITIATED      用户需要的(同样不要使用耗时操作)
     QOS_CLASS_DEFAULT             默认的(给系统来重置队列的)
     QOS_CLASS_UTILITY             使用工具(用来做耗时操作)
     QOS_CLASS_BACKGROUND          后台
     QOS_CLASS_UNSPECIFIED         没有指定优先级
     iOS 7  调度的优先级
     - DISPATCH_QUEUE_PRIORITY_HIGH 2               高优先级
     - DISPATCH_QUEUE_PRIORITY_DEFAULT 0            默认优先级
     - DISPATCH_QUEUE_PRIORITY_LOW (-2)             低优先级
     - DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN 后台优先级
     
     提示:尤其不要选择BACKGROUND 优先级,服务质量,线程执行会慢到令人发指!!!
     
     2. 为未来使用的一个保留,现在始终给0.
     
     老项目中,一般还是没有淘汰iOS 7  ,没法使用服务质量
     */
    dispatch_queue_t q = dispatch_get_global_queue(0, 0);
    dispatch_async(q, ^{
            NSLog(@"%@  %d",[NSThread currentThread],i);
        });

//有依赖关系的任务： 登录后才能支付或下载
//同步任务
-(void)gcdDemo{
    dispatch_queue_t loginQueue = dispatch_queue_create("Thread C", DISPATCH_QUEUE_CONCURRENT);
    //1.用户登录 
    dispatch_sync(loginQueue, ^{
        NSLog(@"用户登录  %@",[NSThread currentThread]); 
    });
    //2.支付
    dispatch_async(loginQueue, ^{
        NSLog(@"支付  %@",[NSThread currentThread]);
    });
    //3.下载
    dispatch_async(loginQueue, ^{
        NSLog(@"下载  %@",[NSThread currentThread]);
    });
}

// 增强版同步任务 - 在子线程中调度
// - 同步任务,会造成一个死锁!
-(void)gcdDemo6{
    dispatch_queue_t q = dispatch_queue_create("Thread D", DISPATCH_QUEUE_CONCURRENT);
    //任务
    void (^task)()=^{
        for (int i = 0; i < 10; i++) {
            NSLog(@"%d   %@",i ,[NSThread currentThread]);
            if (i==5) {
                //1.用户登录
                dispatch_sync(q, ^{
                    for (int i = 0; i < 5; i++) {
                        NSLog(@"用户登录  %@",[NSThread currentThread]);
                    }
                });
            }
        }
        //2.支付
        dispatch_async(q, ^{
            NSLog(@"支付  %@",[NSThread currentThread]);
        });
        
        //3.下载
        dispatch_async(q, ^{
            NSLog(@"下载  %@",[NSThread currentThread]);
        });
   
    };
    dispatch_async(q, task);    
}

//GCD中还有个用来执行任务的函数：
//dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block);
//在前面的任务执行结束后它才执行，而且它后面的任务等它执行完成之后才会执行
//这个queue不能是全局的并发队列

延时执行

一、
    //  调用NSObject的方法
    //  2秒后再调用self的run方法
    [self performSelector:@selector(run) withObject:nil afterDelay:2.0];

二、
    //  使用NSTimer
    [NSTimer scheduledTimerWithTimeInterval:2.0 target:self selector:@selector(test) userInfo:nil repeats:NO];

三、
    /** GCD 函数
     从现在开始,进过多少纳秒之后,让 queue队列,调度 block 任务,异步执行!
     参数:
     1.when、2.queue、3.block
     */
    dispatch_time_t when = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.00003 * NSEC_PER_SEC));
    dispatch_after(when, dispatch_queue_create("Thread D", NULL), ^{
        NSLog(@"%@",[NSThread currentThread]);
    });
//    dispatch_after(when, dispatch_get_main_queue(), ^{
//        NSLog(@"%@",[NSThread currentThread]);
//    });

快速迭代

    //  使用dispatch_apply函数能进行快速迭代遍历
    dispatch_apply(10, dispatch_get_global_queue(0, 0), ^(size_t index){
        // 执行10次代码，index顺序不确定
    });

调度组

//    有这么1种需求
//    首先：分别异步执行2个耗时的操作
//    其次：等2个异步操作都执行完毕后，再回到主线程执行操作
    //1.队列
    dispatch_queue_t q = dispatch_get_global_queue(0, 0);
    
    //2.调度组
    dispatch_group_t g = dispatch_group_create();
    
    //3.添加任务,让队列调度,任务执行情况,最后通知群组
    dispatch_group_async(g, q, ^{
        NSLog(@"download A%@",[NSThread currentThread]);
    });
    dispatch_group_async(g, q, ^{
        NSLog(@"download B%@",[NSThread currentThread]);
    });
    dispatch_group_async(g, q, ^{
        NSLog(@"download C%@",[NSThread currentThread]);
    });
    
    //4.所有任务执行完毕后,通知
    //用一个调度组,可以监听全局队列的任务,主队列去执行最后的任务
    //dispatch_group_notify 本身也是异步的!
    dispatch_group_notify(g, dispatch_get_main_queue(), ^{
        //更新UI,通知用户
        NSLog(@"OK %@",[NSThread currentThread]);
    });

主队列注意事项：

同步任务死锁:当前是在主线程,让主队列执行同步任务!

////前提：gcdDemo2 跑在主线程
- (void)gcdDemo2 {
    //主队列是专门负责在主线程上调度任务的队列 --> 不会开线程
    //1.队列 --> 已启动主线程,就可以获取主队列
    dispatch_queue_t q = dispatch_get_main_queue();
    
    //2.同步任务  ==> 死锁
    dispatch_sync(q, ^{
        NSLog(@"挂掉，因为死锁 ");
    });
    NSLog(@"代码无法走到这一步");

//    dispatch_async(q, ^{
//        NSLog(@"%@",[NSThread currentThread]);
//        NSLog(@"异步任务，正常执行");
//    })
}

//MARK: 主队列同步任务(不死锁的)
- (void)gcdDemo3 {
    void (^task)() = ^{
        //1.队列 --> 已启动主线程,就可以获取主队列
        dispatch_queue_t q = dispatch_get_main_queue();
        
        //2.同步任务
        dispatch_sync(q, ^{
            NSLog(@"先到 %@",[NSThread currentThread]);
        });
        NSLog(@"后到，因为是同步任务");
    };
    
    //开启子线程
    dispatch_async(dispatch_get_global_queue(0, 0), task);
}

线程间通讯

 //    从子线程回到主线程
 dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 执行耗时的异步操作...
        dispatch_async(dispatch_get_main_queue(), ^{
            // 回到主线程，执行UI刷新操作
        });
    });

一次执行

//// 在单例设计模式里面 非常普遍
-(void)once{
    //苹果提供的 一次性机制,不仅能够保证一次执行!而且是线程安全的!!
    static dispatch_once_t onceToken;
    NSLog(@"%ld",onceToken);
    //苹果推荐使用 gcd 一次执行,效率高
    //不要使用互斥锁,效率低!
    dispatch_once(&onceToken, ^{
        //只会执行一次!!
        NSLog(@"执行了%@",[NSThread currentThread]);
    });
}

单例模式

//ARC中，单例模式的实现
//在.m中保留一个全局的static的实例
static id _instance;

//重写allocWithZone:方法，在这里创建唯一的实例（注意线程安全）
+ (instancetype)allocWithZone:(struct _NSZone *)zone
{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _instance = [super allocWithZone:zone];
    });
    return _instance;
}

//提供1个类方法让外界访问唯一的实例
+ (instancetype)sharedInstance
{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _instance = [[self alloc] init];
    });
    return _instance;
}

//实现copyWithZone:方法
- (id)copyWithZone:(struct _NSZone *)zone
{
    return _instance;
}