多线程之—GCD

2016-12-09 本文已影响0人小白文_Vincent

文艺求关注.png

OK，既然讲到多线程，那就一次性把全部多线程的内容介绍完毕～

🔣 简介

<h6>什么是GCD</h6>
- 全称是Grand Central Dispatch，可译为“牛逼的中枢调度器”
- 纯C语言，提供了非常多强大的函数
<h6>GCD的优势</h6>
- GCD是苹果公司为多核的并发运算提出的解决方案
- GCD会自动利用更多的CPU内核（比如双核、四核）
- GCD会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
- 程序猿只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码
<h6>任务和队列</h6>
- 任务：执行什么操作
- 队列：用来存放任务
<h6>GCD的使用就2个步骤</h6>
- 定制任务
  - 确定想要做的事情
- 将任务添加到队列中
  - GCD会自动将队列中的任务取出，放到对应的线程中执行
  - 任务的取出遵循队列的FIFO原则：先进先出，后进后出
<h6>执行任务</h6>
- GCD中有2个用来执行任务的常用函数
<h6>异步函数</h6>

// 异步函数 + 并发队列: 开启多条线程并发执行队列中的任务
// !!!*** 线程的数量并不是有任务的数量决定的，而是由系统决定的
- (void)asyncConcurrent {

1.1 获得并发队列-------------第一种方式

    /**
     第一个参数 C语言字符串 队列表的名称（一般用公司域名：com.vn_vincent.www.DownloadQueue）
     第二个参数 队列的类型
              DISPATCH_QUEUE_CONCURRENT:并发队列
              DISPATCH_QUEUE_SERIAL:串行队列
     */
    dispatch_queue_t queue = dispatch_queue_create("com.vn_vincent.www.DownLoadQueue", DISPATCH_QUEUE_CONCURRENT);

1.2 获得并发队列-----------------第二种方式

    /**
     第一个参数：队列的优先级，一般传default/0
     第二个参数：留给未来使用的，总是传一个0 就可以了
     */
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

2.0 封装任务并把任务添加到队列中

    dispatch_async(queue, ^{
        NSLog(@"downLoad1-------------%@", [NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"downLoad2-------------%@", [NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"downLoad3-------------%@", [NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"downLoad4-------------%@", [NSThread currentThread]);
    });
}

// 异步函数 + 串行队列: 开启一条子线程，串行执行任务
- (void)asyncSerial {

1.0 获得并发队列

    /**
     第一个参数 C语言字符串 队列表的名称（一般用公司域名：com.vn_vincent.www.DownloadQueue）
     第二个参数 队列的类型 description#>
              DISPATCH_QUEUE_CONCURRENT:并发队列
              DISPATCH_QUEUE_SERIAL:串行队列
     */
    dispatch_queue_t queue = dispatch_queue_create("com.vn_vincent.www.DownLoadQueue", DISPATCH_QUEUE_SERIAL);

2.0 封装任务并把任务添加到队列中

    dispatch_async(queue, ^{
        NSLog(@"downLoad1-------------%@", [NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"downLoad2-------------%@", [NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"downLoad3-------------%@", [NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"downLoad4-------------%@", [NSThread currentThread]);
    });
}

// 异步函数 + 主队列：不会开子线程，所有任务都在主线程中串行执行
- (void)asyncMain {

1.0 获得主队列

    dispatch_queue_t queue = dispatch_get_main_queue();

2.0封装任务并把任务封装到队列中去


    dispatch_sync(queue, ^{
        NSLog(@"downLoad1-----------------%@", [NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"downLoad2-----------------%@", [NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"downLoad3-----------------%@", [NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"downLoad4-----------------%@", [NSThread currentThread]);
    });
}

<b>同步函数：dispatch_sync

不具备开子线程的能力，可以开子线程
执行任务的方式：同步

异步函数：dispatch_async

具备开线程的能力
执行任务的方式：异步

队列的类型

“并发队列”：队列中的任务可以同时执行（异步）
- 获得方法：
  1⃣️ 自己创建（concurrent）
  2⃣️ 全局并发队列
“串行队列”：队列中的任务只能一个接着一个的执行
- 获得方法：
  1⃣️ 自己创建（serial）
  2⃣️ 主队列：串行 | 在主队列中的所有的任务都必须在主队列中执行 | 调度时比较特殊(！)
  </b>
<b>同步函数</b>

// 同步函数 + 并发队列: 不会开子线程，所有任务在当前线程中串行执行
- (void)syncConcurrent {

1.0 获得并发队列

    /**
     第一个参数 C语言字符串 队列表的名称（一般用公司域名：com.vn_vincent.www.DownloadQueue）
     第二个参数 队列的类型
     DISPATCH_QUEUE_CONCURRENT:并发队列
     DISPATCH_QUEUE_SERIAL:串行队列
     */
    dispatch_queue_t queue = dispatch_queue_create("com.vn_vincent.www.DownLoadQueue", DISPATCH_QUEUE_CONCURRENT);

2.0 封装任务并把任务添加到队列中去

    dispatch_sync(queue, ^{
        NSLog(@"downLoad1-------------%@", [NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"download2-------------%@", [NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"downLoad3-------------%@", [NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"download4-------------%@", [NSThread currentThread]);
    });
}

// 同步函数 + 串行队列: 不会开子线程，所以任务在当前线程中串行执行
- (void)syncSerial {

1.0 获得并发队列

    /**
     第一个参数 C语言字符串 队列表的名称（一般用公司域名：com.vn_vincent.www.DownloadQueue）
     第二个参数 队列的类型 description#>
     DISPATCH_QUEUE_CONCURRENT:并发队列
     DISPATCH_QUEUE_SERIAL:串行队列
     */
    dispatch_queue_t queue = dispatch_queue_create("com.vn_vincent.www.DownloadQueue", DISPATCH_QUEUE_SERIAL);

2.0 封装任务并把任务添加到队列中去


    dispatch_sync(queue, ^{
        NSLog(@"downLoad1-------------%@", [NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"downLoad2-------------%@", [NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"downLoad3-------------%@", [NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"downLoad4-------------%@", [NSThread currentThread]);
    });
}

// 同步函数 + 主队列：会发生死锁
- (void)syncMain {

1.0 获取主队列

    dispatch_queue_t queue = dispatch_get_main_queue();
    
    NSLog(@"start");
    // **!! 当主队列中有任务要执行的时候，会安排主线程来执行任务，\
            但是在安排之前会先检查主线程的状态，如果空闲则执行，否则就暂停调度 \
            等待到主线程空闲为止

2.0 封装任务并把任务封装到队列中去

    dispatch_sync(queue, ^{
        NSLog(@"downLoad1-----------------%@", [NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"downLoad2-----------------%@", [NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"downLoad3-----------------%@", [NSThread currentThread]);
    });
}

<b>GCD线程间通信</b>

@property (weak, nonatomic) IBOutlet UIImageView *imageView;
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {

GCD开子线程— 1.0（并发|串行）获得队列

//    DISPATCH_QUEUE_PRIORITY_DEFAULT == 0
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);

2.0 封装任务，异步 | 完成线程间通信

    dispatch_async(queue, ^{
        NSURL *url = [NSURL URLWithString:@""];
        NSData *imageData = [NSData dataWithContentsOfURL:url];
        UIImage *image = [UIImage imageWithData:imageData];
        
        // 回到主线程刷新UI
        // 下面方法也可以实现线程间通信
//        [self performSelectorOnMainThread:<#(nonnull SEL)#> withObject:<#(nullable id)#> waitUntilDone:<#(BOOL)#>]
        
        // dispatch_get_main_queue(）
        // 异步函数(同步函数) + 主队列
        dispatch_async(dispatch_get_main_queue(), ^{
            self.imageView.image = image;
        });
    });
}

<b>GCD中常见的函数</b></br>
一次性函数 1)整个程序运行中只会执行一次 2）线程安全

- (void)once {
    
    NSLog(@"start");

    static dispatch_once_t onceToken;
    // 内部实现原理：最开始 onceToken == 0；如果onceToken == 0，那么就执行一次下面的block代码块，onceToken == -1
    dispatch_once(&onceToken, ^{
        NSLog(@"once");
    });
}

GCD延迟操作

- (void)defer {
    
    NSLog(@"start");

延迟的第一种方法：NSTimer

    [NSTimer scheduledTimerWithTimeInterval:2.0 target:self selector:@selector(tesk) userInfo:nil repeats:NO];

延迟的第二种方法：

    [self performSelector:@selector(tesk) withObject:nil afterDelay:2.0];

延迟的第三种方法：GCD

    // * == 乘 GCD中事件事件单位为纳秒（nm）
    /**
     主队列：主线程
     全局并发队列：子线程
     自己创建的并发队列：子线程
     自己创建的穿行队列：子线程
     dispatch_after：本质上是一个异步函数
     */
//    dispatch_queue_t queue = dispatch_get_main_queue();
//    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
//    dispatch_queue_t queue = dispatch_queue_create("com.vn_vincent.www", DISPATCH_QUEUE_CONCURRENT);
    dispatch_queue_t queue = dispatch_queue_create("com.vn_vincent.www", DISPATCH_QUEUE_SERIAL);
    // 内部实现原理：延迟2秒，然后再把任务提交到队列中
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), queue, ^{
        NSLog(@"GCD---------%@", [NSThread currentThread]);
    });
}

- (void) tesk {
    NSLog(@"tesk");
}

GCD迭代

- (void)apply {

    // 迭代 == 遍历
    // 特点：在当前线程中串行完成
    for (NSInteger i = 0; i < 10; i++) {
        NSLog(@"%zd-------------%@", i, [NSThread currentThread]);
    }
    
    NSLog(@"----------------------------------");

    /**
     GCD的快速迭代*(开发中一般使用并发队列)：会开启子线程和主线程一起执行任务，所有的任务并发执行
     第一个参数 遍历次数
     第二个参数 队列 ～ 线程
        传入的队列：自己创建的并发队列 == 全局并发队列
                  自己创建的串行队列 == for in 循环 （不会开启子线程所有任务，串行执行）
                  主队列：产生死锁
     第三个参数 size_t 类似于for遍历的中的 i
     */
    
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    dispatch_apply(10, queue, ^(size_t i) {
        NSLog(@"%zd-------------%@", i, [NSThread currentThread]);
    });
}

GCD快速迭代应用

- (void)moveImage {
    // 需求，桌面上有两个文件夹（oldImage|newImage），要求，将其中一个文件夹(oldImage)内的所有文件剪切到另一个文件夹(newImage)中

    // 01.得到上级文件夹的路径
    NSString *oldPath = @"/Users/Vincent/Desktop/oldImage";
    NSString *newPath = @"/Users/Vincent/Desktop/newImage";

    // 02.获得所有文件
    NSArray *subPaths = [[NSFileManager defaultManager] subpathsAtPath:oldPath];
    NSLog(@"%@", subPaths);

    // 03.便利并剪切文件
    dispatch_apply(subPaths.count, dispatch_get_global_queue(0, 0), ^(size_t index) {
        
        NSString *fileName = subPaths[index];
        // 拼接字符串得到文件名
        NSString *oldFullPath = [oldPath stringByAppendingPathComponent:fileName];
        NSString *newFullPath = [newPath stringByAppendingPathComponent:fileName];

        // 04.剪切文件
        [[NSFileManager defaultManager] moveItemAtPath:oldFullPath toPath:newFullPath error:nil];
        
        NSLog(@"%@-------%@----------%@", oldFullPath, newFullPath, [NSThread currentThread]);
    });
}

GCD栅栏函数使用

// 栅栏函数不能使用全局并发队列
- (void) barrier {

    // 需求：1）有四个任务，开子线程并发的执行这四个任务
    //      2) 添加任务“临时任务”，但是要求必须要等1|2任务完成后执行，必须要等临时任务完成，才能执行后面的任务
    //      3）所有的任务都在子线程中完成（dispatch_async）;
    //      4)"临时任务“需要在子线程中完成（dispatch_sync）;

01.获得并发队列

    dispatch_queue_t queue = dispatch_queue_create("com.vn_vincent.www.TextQueue", DISPATCH_QUEUE_CONCURRENT);

02.异步函数

    dispatch_async(queue, ^{
        NSLog(@"任务1完成--------------%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"任务2完成--------------%@", [NSThread currentThread]);
    });

    // 栅栏函数  Barrier

    dispatch_barrier_async(queue, ^{
        NSLog(@"+++++++临时任务+++++++++, %@", [NSThread currentThread]);
    });

    dispatch_async(queue, ^{
        NSLog(@"任务3完成--------------%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"任务4完成--------------%@", [NSThread currentThread]);
    });
}

GCD 队列组

- (void)groupQueue01 {

01.创建队列

    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);

02.创建队列组

    dispatch_group_t group = dispatch_group_create();

03.封装任务，并把任务添加到异步队列

    /**
     1) 封装任务
     2) 把任务添加到队列中
    dispatch_async(queue, ^{
        NSLog(@"%@", [NSThread currentThread]);
    });
     */
    
    /**
     1) 封装任务
     2) 把任务添加到队列中
     3）会监听任务的执行情况，通知group
     */
    dispatch_group_async(group, queue, ^{
        NSLog(@"1------------------%@", [NSThread currentThread]);
    });
    
    dispatch_group_async(group, queue, ^{
        NSLog(@"2------------------%@", [NSThread currentThread]);
    });
    
    dispatch_group_async(group, queue, ^{
        NSLog(@"3------------------%@", [NSThread currentThread]);
    });

    // 拦截通知，当队列中所有任务的任务都执行完毕的时候会进行下面的任务执行
    // 内部本身是异步的，不会堵塞

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

    // 拦截通知的另一种方法
    // DISPATCH_TIME_FOREVER 等待，死等.直到队列中所有的任务都执行完毕之后才会执行
    // 阻塞的

    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
    NSLog(@"------------end-------------");
}

老写法

- (void)groupQueue02 {

01.创建队列

    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);

02.创建队列组

    dispatch_group_t group = dispatch_group_create();

03.在该方法后面的异步任务会被纳入到队列组的监听范围，进入群组
dispatch_group_enter | dispatch_group_leave 必须要配对使用

    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        NSLog(@"1--------------%@", [NSThread currentThread]);
        
        // 离开群组
        dispatch_group_leave(group);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"2--------------%@", [NSThread currentThread]);
        
        // 离开群组
        dispatch_group_leave(group);
    });

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

GCD 队列组使用(需求，下载两个图片，并将两个图片合并成一张图片)

@property (weak, nonatomic) IBOutlet UIImageView *imageView;

// 第一张图
@property (nonatomic, strong) UIImage *image1;
// 第二张图
@property (nonatomic, strong) UIImage *image2;

- (void) groupQueueAdhibition {

01.创建队列组

    dispatch_group_t group = dispatch_group_create();

02.获取并发队列

    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);

03.下载图片一，开子线程

    dispatch_group_async(group, queue, ^{
        
        // 3.1.获取图片的URL
        NSURL *url = [NSURL URLWithString:@"http://scimg.jb51.net/allimg/151109/14-15110Z9535JH.jpg"];
        
        // 3.2.下载图片的二进制数据
        NSData *image1Data = [NSData dataWithContentsOfURL:url];
        
        // 3.3.转换图片
        self.image1 = [UIImage imageWithData:image1Data];
    });

04.下载图片二，开子线程

    dispatch_group_async(group, queue, ^{
        
        // 4.1.获取图片的URL
        NSURL *url = [NSURL URLWithString:@"http://pic.qiantucdn.com/58pic/18/12/74/50B58PICWPb_1024.jpg"];
        
        // 4.2.下载图片的二进制数据
        NSData *image2Data = [NSData dataWithContentsOfURL:url];
        
        // 4.3.转换图片
        self.image2 = [UIImage imageWithData:image2Data];
    });

05.合并图片

    dispatch_group_notify(group, queue, ^{
        // 5.1 创建图形上下文
        UIGraphicsBeginImageContext(CGSizeMake(300, 300));
        
        // 5.2 画图1
        [self.image1 drawInRect:CGRectMake(0, 0, 300, 150)];
        self.image1 = nil;
        
        // 5.3 画图2
        [self.image2 drawInRect:CGRectMake(0, 150, 300, 150)];
        self.image2 = nil;
        
        // 5.4 根据上下文得到一张图片
        UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
        
        // 5.5 关闭上下文
        UIGraphicsEndImageContext();
        
        // 5.6 刷新UI
       dispatch_async(dispatch_get_main_queue(), ^{
           self.imageView.image = image;
       });
        
    });
}

GCD补充知识点

- (void) test02 {
    
//    dispatch_async(<#dispatch_queue_t  _Nonnull queue#>, <#^(void)block#>)
    // 封装任务的方法不同（⬆️：Block， ⬇️：函数）
    /**
     第一个参数：队列
     第二个参数：函数参数
     第三个参数：要调用的函数名称
     */
    // 会开子线程，完成任务
    dispatch_async_f(dispatch_get_global_queue(0, 0), NULL, task);
    dispatch_async_f(dispatch_get_global_queue(0, 0), NULL, task);
    dispatch_async_f(dispatch_get_global_queue(0, 0), NULL, task);
}

void task(void *param) {

    NSLog(@"%s-----------%@", __func__, [NSThread currentThread]);
}

关注一下又不会怀孕.png

多线程之—GCD

🔣 简介

猜你喜欢

热点阅读