iOS 多线程之GCD

2019-03-13 本文已影响0人尤先森

什么是GCD？

全称是 Grand Central Dispatch
纯 C 语言，提供了非常多强大的函数

GCD的优势

GCD 是苹果公司为多核的并行运算提出的解决方案
GCD 会自动利用更多的CPU内核（比如双核、四核）
GCD 会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
程序员只需要告诉 GCD 想要执行什么任务，不需要编写任何线程管理代码

GCD做了啥

将任务添加到队列，并且指定执行任务的函数

    //1.创建任务block
    dispatch_block_t task = ^{
        NSLog(@"要执行的任务");
    };
    //2.获取/创建队列
    dispatch_queue_t getQueue = dispatch_get_global_queue(0, 0);
    //3.调用同/异步函数
    dispatch_async(getQueue, task);

队列与函数

队列

image.png

串行队列：任务必须按照先后顺序执行，先进先出。
并发队列：任务可同时执行。

系统自动创建的队列

主队列：dispatch_get_main_queue();
- 是一条捆绑在主线程上的队列
- 专门用来在主线程上调度任务的队列
- 不会开启线程
- 如果当前主线程正在有任务执行，那么无论主队列中当前被添加了什么任务，都不会被调度
- 主队列用于在应用程序中与主线程和主runloop交互。
- 主队列不完全像普通串行队列。用于非UI应用程序的进程时，它可能会产生不必要的副作用。
全局并发队列：dispatch_get_global_queue(0, 0)
- 全局队列是一个并发队列
- 在使用多线程开发时，如果对队列没有特殊需求，在执行异步任务时，可以直接使用全局队列

函数

同步函数：dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);
异步函数：dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

队列与函数相结合

同步串行队列
- 不会开启线程，在当前线程执行任务
- 任务串行执行，任务一个接着一个
- 会产生堵塞
同步并发队列
- 不会开启线程，在当前线程执行任务
- 任务一个接着一个
异步串行队列
- 开启线程一条新线程
- 任务一个接着一个
异步并发队列
- 开启线程，在当前线程执行任务
- 任务异步执行，没有顺序，CPU调度有关

如果在同步函数或者串行队列中再加入一个同步函数或者串行队列，就很容易造成死锁。

死锁

主线程因为你同步函数的原因等着先执行任务
主队列等着主线程的任务执行完毕再执行自己的任务
主队列和主线程相互等待会造成死锁

tips:
1.主队列类似于串行队列。
2.主线程执行任务，也是按照代码从上至下执行，所以主线程中也类似执行着同步函数。

GCD的应用

单例

@interface Person : NSObject
+(instancetype)shareInstance;
@end


static Person *person = nil;
@implementation Person
+(instancetype)shareInstance{
    static dispatch_once_t token;
    if (person == nil) {
        dispatch_once(&token, ^{
            person  = [[Person alloc]init];
        });
    }
    return person;
}
+(instancetype)allocWithZone:(struct _NSZone *)zone{
    return  [self shareInstance];
}
- (id)copyWithZone:(NSZone *)zone
{
    return self;
}

- (id)mutableCopyWithZone:(NSZone *)zone
{
    return self;
}

@end

延迟执行

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"延迟执行");
});

信号量控制并发数(也可以起到锁的作用)

//创造信号量，设置并发数为2
dispatch_semaphore_t lock =  dispatch_semaphore_create(2);
//信号量等待
dispatch_semaphore_wait(lock, DISPATCH_TIME_FOREVER);
//信号量释放。
dispatch_semaphore_signal(lock);

栅栏函数

控制任务执行顺序
dispatch_barrier_async:前面的任务执行完毕才会来到这里
dispatch_barrier_sync:作用相同,但是这个会堵塞线程,影响后面的任务执行（不论任务是否在队列内）。
重点: 栅栏函数只能控制同一并发队列,且这条队列需要自己创建,不同队列将无法生效。

    // 创建并发队列
    dispatch_queue_t concurrentQueue = dispatch_queue_create("myqueue", DISPATCH_QUEUE_CONCURRENT);
    //异步函数一   
    dispatch_async(concurrentQueue, ^{
        NSLog(@"任务一完成");
    }); 
    //异步函数二   
    dispatch_async(concurrentQueue, ^{
        NSLog(@"任务二完成");
    });
    //栅栏函数
    dispatch_barrier_async(concurrentQueue, ^{
        NSLog(@"上面两个任务都完成了，总算轮到我了。");
    });
    NSLog(@"如果栅栏函数是异步的，我会先执行；但如果是同步的话，我就得在栅栏函数执行完后，才能执行");

保证线程安全

    dispatch_queue_t concurrentQueue = dispatch_queue_create("myQueen", DISPATCH_QUEUE_CONCURRENT);
    for (int i = 0; i<2000; i++) {
        dispatch_async(concurrentQueue, ^{
            NSString *imageName = [NSString stringWithFormat:@"%d.jpg", (i % 10)];
            NSURL *url = [[NSBundle mainBundle] URLForResource:imageName withExtension:nil];
            NSData *data = [NSData dataWithContentsOfURL:url];
            UIImage *image = [UIImage imageWithData:data];
            //如果没有栅栏函数，会崩溃。
            dispatch_barrier_async(concurrentQueue, ^{
                [self.mArray addObject:image];
            });
        });
    }

调度组

控制任务执行顺序
dispatch_group_t group = dispatch_group_create: 创建组
dispatch_queue_t queue = dispatch_group_async: 进组任务
dispatch_group_notify:进组任务执行完毕通知
dispatch_group_wait:进组任务执行等待时间

    //创建调度组
    dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    dispatch_queue_t queue1 = dispatch_queue_create("myQueue", DISPATCH_QUEUE_CONCURRENT);

    dispatch_group_async(group, queue, ^{
        NSLog(@"任务一");
    });
    
    dispatch_group_async(group, queue1, ^{
        NSLog(@"任务二");
    });
    
    dispatch_group_notify(group, queue, ^{
        NSLog(@"任务结束");
    });

dispatch_group_enter:进组
dispatch_group_leave:出组
调用enter跟leave需要注意，要一一对应。
enter 多于 leave 不会调用通知notify。
enter 少于 leave 就会奔溃。

    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    dispatch_group_t group = dispatch_group_create();
    
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        NSLog(@"第一个走完了");
        dispatch_group_leave(group);
    });
    
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        NSLog(@"第二个走完了");
        dispatch_group_leave(group);
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        NSLog(@"所有任务完成,可以更新UI");
    });

源 Dispatch_source(跟RunLoop的源不一样)

@property (nonatomic, strong) dispatch_source_t source;
@property (nonatomic, strong) dispatch_queue_t queue;

- (void)viewDidLoad {
    [super viewDidLoad];
    self.queue = dispatch_queue_create("myQueue", 0);
    self.source = dispatch_source_create(DISPATCH_SOURCE_TYPE_DATA_ADD, 0, 0, dispatch_get_main_queue());

    dispatch_source_set_event_handler(self.source, ^{
    NSUInteger value = dispatch_source_get_data(self.source); // 取回来值 1 响应式
    NSLog(@"响应回来的值 === %lu",value);
});
//默认是挂起的，不resume就不执行
dispatch_resume(self.source);
}
//触发事件
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
    dispatch_source_merge_data(self.source, 1); // source 值响应
}

待续