GCD - 符琼林的个人博客

GCD 简介

什么是GCD？

全称是 Grand Central Dispatch
纯 C 语言，提供了非常多强大的函数
GCD的优势
- GCD 是苹果公司为多核的并行运算提出的解决方案
- GCD 会自动利用更多的CPU内核（比如双核、四核）
- GCD 会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
- 程序员只需要告诉 GCD 想要执行什么任务，不需要编写任何线程管理代码

函数与队列

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

任务使用 block 封装
- 任务的 block 没有参数也没有返回值
执行任务的函数
- 异步 dispatch_async
  - 不用等待当前语句执行完毕，就可以执行下一条语句
  - 会开启线程执行 block 的任务
  - 异步是多线程的代名词
- 同步 dispatch_sync
  - 必须等待当前语句执行完毕，才会执行下一条语句
  - 不会开启线程
  - 在当前执行 block 的任务

注意：异步执行（async）虽然具有开启新线程的能力，但是并不一定开启新线程。这跟任务所指定的队列类型有关

/**
 * 还原最基础的写法,很重要
 */

- (void)syncTest{
    
    //1:创建串行队列
    dispatch_queue_t queue = dispatch_queue_create("Bear", DISPATCH_QUEUE_SERIAL);
    //下面的方式也可以,但是用得少, DISPATCH_QUEUE_SERIAL 更加易懂
    //dispatch_queue_t queue = dispatch_queue_create("Bear", NULL);
    
    //2:创建任务
    dispatch_block_t taskBlock = ^{
        NSLog(@"%@",[NSThread currentThread]);
    };
    //3:利用函数把任务放入队列
    dispatch_sync(queue, taskBlock);
    
}

//把任务添加到队列依赖于函数
/**
 串行同步队列 : FIFO: 先进先出
 */
- (void)serialSyncTest{
    //1:创建串行队列
    dispatch_queue_t queue = dispatch_queue_create("Bear", DISPATCH_QUEUE_SERIAL);
    for (int i = 0; i<20; i++) {
        dispatch_sync(queue, ^{
            NSLog(@"%d-%@",i,[NSThread currentThread]);
        });
    }

}


/**
 串行异步队列
 */
- (void)serialAsyncTest{
    //1:创建串行队列
    dispatch_queue_t queue = dispatch_queue_create("Bear", DISPATCH_QUEUE_SERIAL);
    for (int i = 0; i<20; i++) {
        dispatch_async(queue, ^{
            NSLog(@"%d-%@",i,[NSThread currentThread]);
        });
    }
    
    for (int i = 0; i<1000000; i++) {

    }
    
    NSLog(@"hello queue");
    
}


/**
 异步并发: 有了异步函数不一定开辟线程
 */
- (void)concurrentAsyncTest{
    //1:创建并发队列
    dispatch_queue_t queue = dispatch_queue_create("Bear", DISPATCH_QUEUE_CONCURRENT);
    for (int i = 0; i<20; i++) {
        dispatch_async(queue, ^{
            NSLog(@"%d-%@",i,[NSThread currentThread]);
        });
    }
    
    for (int i = 0; i<1000000; i++) {

    }
    
    NSLog(@"hello queue");
    
}

/**
 同步并发 : 堵塞 同步锁  
 队列 : resume supend   
 线程 操作, 队列挂起 任务能否执行？
 */
- (void)concurrentSyncTest{

    //1:创建并发队列
    dispatch_queue_t queue = dispatch_queue_create("Bear", DISPATCH_QUEUE_CONCURRENT);
    for (int i = 0; i<20; i++) {
        dispatch_sync(queue, ^{
            NSLog(@"%d-%@",i,[NSThread currentThread]);
        });
    }
    
    for (int i = 0; i<1000000; i++) {
 
    }
    NSLog(@"hello queue");
}

函数与队列组合应用

/*
串行：DISPATCH_QUEUE_SERIAL
并发：DISPATCH_QUEUE_CONCURRENT
*/
- (void)textDemo{
    dispatch_queue_t queue = dispatch_queue_create("Bear", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"1");
    dispatch_async(queue, ^{
        NSLog(@"2");
        dispatch_async(queue, ^{
            NSLog(@"3");
        });
        NSLog(@"4");
    });
    NSLog(@"5");
    
    //  1 5 2 4 3
}


- (void)textDemo1{
    
    dispatch_queue_t queue = dispatch_queue_create("Bear", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"1");
    dispatch_async(queue, ^{
        NSLog(@"2");
        dispatch_sync(queue, ^{
            NSLog(@"3");
        });
        NSLog(@"4");
    });
    NSLog(@"5");
    
    // 1 5 2 3 4
}


/**
 函数 队列  ---> 死锁  线程 执行顺序
 主队列(serial)  全局队列 (concurrent)
 */

- (void)textDemo2{
    
    // 同步队列
    dispatch_queue_t queue = dispatch_queue_create("Bear", DISPATCH_QUEUE_SERIAL);
    NSLog(@"1");
    // 异步函数
    dispatch_async(queue, ^{
        NSLog(@"2");
        
        // 同步,先执行3！！！
        dispatch_sync(queue, ^{
            NSLog(@"3");
        });
        NSLog(@"4");
    });
    NSLog(@"5");
    
    // 1 5 2
    
}

主队列
- 专门用来在主线程上调度任务的队列
- 不会开启线程
- 如果当前主线程正在有任务执行，那么无论主队列中当前被添加了什么任务，都不会被调度
- dispatch_get_main_queue();
全局队列
- 为了方便程序员的使用，苹果提供了全局队列 dispatch_get_global_queue(0, 0)
- 全局队列是一个并发队列
- 在使用多线程开发时，如果对队列没有特殊需求，在执行异步任务时，可以直接使用全局队列

/**
 函数 队列  ---> 死锁  线程 执行顺序
 主队列(serial)  全局队列 (concurrent)
 */

/**
 主队列同步
 不会开线程
 */
- (void)mainSyncTest{
    
    // 主队列 存在任务就会执行到底
    // dispatch_get_main_queue() -->
    NSLog(@"0");
    // 等
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"1");
    });
    NSLog(@"2");
}
/**
 主队列异步
 不会开线程 顺序
 */
- (void)mainAsyncTest{
    dispatch_async(dispatch_get_main_queue(), ^{
        NSLog(@"1");
    });
    NSLog(@"2");
}


/**
 全局异步
 全局队列:一个并发队列
 */
- (void)globalAsyncTest{
    for (int i = 0; i<20; i++) {
        
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            NSLog(@"%d-%@",i,[NSThread currentThread]);
        });
    }
    
    for (int i = 0; i<1000000; i++) {
    }
    NSLog(@"hello queue");
}

/**
 全局同步
 全局队列:一个并发队列
 */
- (void)globalSyncTest{
    for (int i = 0; i<20; i++) {
        dispatch_sync(dispatch_get_global_queue(0, 0), ^{
            NSLog(@"%d-%@",i,[NSThread currentThread]);
        });
    }
    
    for (int i = 0; i<1000000; i++) {
    }
    NSLog(@"hello queue");
}

//面试题
- (void)viewDidLoad {
    [super viewDidLoad];
    
    __block int a = 0;

    // dispatch_get_global_queue : 并发队列
    while (a<5) {
        
        // 耗时足够长  ---  开辟线程能够调度回来  a++  线程不安全 dispatch_async(dispatch_get_global_queue(0, 0), ^{
            NSLog(@"%@===%d",[NSThread currentThread],a);
            a++;
        });
    }
    NSLog(@"%@****%d",[NSThread currentThread],a);
    
    dispatch_sync(dispatch_get_global_queue(0, 0), ^{
        
        NSLog(@"%@--------%d",[NSThread currentThread],a);

    });
    
    // a > 5
} 		

死锁：

主线程因为你同步函数的原因等着先执行任务

主队列等着主线程的任务执行完毕再执行自己的任务

主队列等着主线程的任务执行完毕再执行自己的任务

GCD应用栅栏函数

顺序执行
线程安全
barrier不能用来封装网络异步请求不是同一个queue保证不了任务顺序执行

//水印 栅栏函数影响
- (void)demo1{
    dispatch_queue_t concurrentQueue = dispatch_queue_create("cooci", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(concurrentQueue, ^{
        NSString *logoStr = @"https://ss0.bdstatic.com/70cFuHSh_Q1YnxGkpoWK1HF6hhy/it/u=3351002169,4211425181&fm=27&gp=0.jpg";
        NSData *data = [NSData dataWithContentsOfURL:[NSURL URLWithString:logoStr]];
        UIImage *image = [UIImage imageWithData:data];
        [self.mArray addObject:image];
    });
    
    dispatch_async(concurrentQueue, ^{
        NSString *logoStr = @"https://ss2.bdstatic.com/70cFvnSh_Q1YnxGkpoWK1HF6hhy/it/u=3033952616,135704646&fm=27&gp=0.jpg";
        NSData *data = [NSData dataWithContentsOfURL:[NSURL URLWithString:logoStr]];
        UIImage *image = [UIImage imageWithData:data];
        [self.mArray addObject:image];
    });
    
    //加载完毕了 栅栏函数上
    __block UIImage *newImage = nil;
    //barrier不能用来封装网络异步请求不是同一个queue保证不了任务顺序执行
    dispatch_barrier_async(concurrentQueue, ^{
        
        for (int i = 0; i<self.mArray.count; i++) {
            UIImage *waterImage = self.mArray[i];
            newImage =[KC_ImageTool kc_WaterImageWithWaterImage:waterImage backImage:newImage waterImageRect:CGRectMake(20, 100*(i+1), 100, 40)];
        }
    });
    
    
    dispatch_async(concurrentQueue, ^{
        dispatch_async(dispatch_get_main_queue(), ^{
            self.imageView.image = newImage;
        });
    });
}

/**
 栅栏函数的演示说明:dispatch_barrier_sync/dispatch_barrier_async
 */
- (void)demo2{
    dispatch_queue_t concurrentQueue = dispatch_queue_create("cooci", DISPATCH_QUEUE_CONCURRENT);
    /* 1.异步函数 */
    dispatch_async(concurrentQueue, ^{
        for (NSUInteger i = 0; i < 5; i++) {
            NSLog(@"download1-%zd-%@",i,[NSThread currentThread]);
        }
    });
    
    dispatch_async(concurrentQueue, ^{
        for (NSUInteger i = 0; i < 5; i++) {
            NSLog(@"download2-%zd-%@",i,[NSThread currentThread]);
        }
    });
    
    /* 2. 栅栏函数 */
    dispatch_barrier_sync(concurrentQueue, ^{
        NSLog(@"---------------------%@------------------------",[NSThread currentThread]);
    });
    NSLog(@"加载那么多,喘口气!!!");
    /* 3. 异步函数 */
    dispatch_async(concurrentQueue, ^{
        for (NSUInteger i = 0; i < 5; i++) {
            NSLog(@"日常处理3-%zd-%@",i,[NSThread currentThread]);
        }
    });
    NSLog(@"休尼MB,起来干!!");
    
    dispatch_async(concurrentQueue, ^{
        for (NSUInteger i = 0; i < 5; i++) {
            NSLog(@"日常处理4-%zd-%@",i,[NSThread currentThread]);
        }
    });
}

/**
 可变数组 线程不安全 解决办法
 */
- (void)demo3{
    
    // 顺序执行
    // 线程安全
    
    dispatch_queue_t concurrentQueue = dispatch_queue_create("cooci", DISPATCH_QUEUE_CONCURRENT);
//    dispatch_queue_t concurrentQueue = dispatch_get_global_queue(0, 0);

    // signal
    for (int i = 0; i<10000; 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];
            NSLog(@"%zd --- %@ ---- %d",self.mArray.count,[NSThread currentThread],i);
            dispatch_barrier_async(concurrentQueue, ^{
                [self.mArray addObject:image];
                NSLog(@"%zd --- %@ ---- %d",self.mArray.count,[NSThread currentThread],i);
            });
//            @synchronized(self){
//               [self.mArray addObject:image];
//            }
            if (i==1999) {
                NSLog(@":%zd",self.mArray.count);
            }
        });
    }
}

GCD应用调度组

/**
 调度组内部方法 enter - leave
 */
- (void)groupDemo2{
    
    // 问题: 如果 dispatch_group_enter 多 dispatch_group_leave 不会调用通知
    // dispatch_group_enter 少 dispatch_group_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_notify(group, dispatch_get_main_queue(), ^{
        NSLog(@"所有任务完成,可以更新UI");
    });
    
}

最大并发数

- (void)viewDidLoad {
    [super viewDidLoad];

    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    //信号量
    //总结：由于设定的信号值为3，先执行三个线程，等执行完一个，才会继续执行下一个，保证同一时间执行的线程数不超过3
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(2);
    
    //任务1
    dispatch_async(queue, ^{
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSLog(@"执行任务1");
        sleep(1);
        NSLog(@"任务1完成");
        dispatch_semaphore_signal(semaphore);
    });
    
    //任务2
    dispatch_async(queue, ^{
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSLog(@"执行任务2");
        sleep(1);
        NSLog(@"任务2完成");
        dispatch_semaphore_signal(semaphore);
    });
    
    //任务3
    dispatch_async(queue, ^{
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSLog(@"执行任务3");
        sleep(1);
        NSLog(@"任务3完成");
        dispatch_semaphore_signal(semaphore);
    });
}

GCD源

Dispatch Source

其 CPU 负荷非常小，尽量不占用资源
联结的优势
在任一线程上调用它的的一个函数 dispatch_source_merge_data 后，会执行 Dispatch Source 事先定义好的句柄（可以把句柄简单理解为一个 block ）
这个过程叫 Custom event ,用户事件。是 dispatch source 支持处理的一种事件
句柄是一种指向指针的指针它指向的就是一个类或者结构，它和系统有很密切的关系
HINSTANCE（实例句柄），HBITMAP（位图句柄），HDC（设备表述句柄），HICON（图标句柄）等。这当中还有一个通用的句柄，就是HANDLE，比如下面的语句：
source类型

#import "ViewController.h"

@interface ViewController ()
@property (weak, nonatomic) IBOutlet UIProgressView *progressView;
@property (nonatomic, strong) dispatch_source_t source;
@property (nonatomic, strong) dispatch_queue_t queue;

@property (nonatomic, assign) NSUInteger totalComplete;
@property (nonatomic) BOOL isRunning;
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    self.totalComplete = 0;
    
    self.queue = dispatch_queue_create("com.tz.cn.cooci", 0);
    
    self.source = dispatch_source_create(DISPATCH_SOURCE_TYPE_DATA_ADD, 0, 0, dispatch_get_main_queue());
    
    /**
     1: 创建source
     2: 绑定回调
     3: 触发函数
     */
    
    // runloop ---> source
    // 下面的函数是 调用封装source
    // 封装任务块 ---->  函数触发
    dispatch_sync(_queue, ^{
        
    });
    
    // 保存代码块 ---> 异步 dispatch_source_set_event_handler()
    // 封装我们需要回调的触发函数
    dispatch_source_set_event_handler(self.source, ^{
        
        NSUInteger value = dispatch_source_get_data(self.source);
        self.totalComplete += value;
        NSLog(@"进度：%.2f", self.totalComplete/100.0);
        self.progressView.progress = self.totalComplete/100.0;
    });
    //记录状态
    self.isRunning     = YES;
    dispatch_resume(self.source);
    // resume (OC): dispatch_resume (c)
    // [task resume]
}


- (IBAction)didClickStartOrPauseAction:(id)sender {

    if (self.isRunning) {// 正在跑就暂停
        dispatch_suspend(self.source);
        dispatch_suspend(self.queue);// mainqueue 挂起
        self.isRunning = NO;
        [sender setTitle:@"暂停中..." forState:UIControlStateNormal];
    }else{
        dispatch_resume(self.source);
        dispatch_resume(self.queue);
        self.isRunning = YES;
        [sender setTitle:@"加载中..." forState:UIControlStateNormal];
    }
   
}

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{

    NSLog(@"点击开始加载");
    
    for (NSUInteger index = 0; index < 100; index++) {
        dispatch_async(self.queue, ^{
            if (!self.isRunning) {
                NSLog(@"暂停下载");
                return ;
            }
            sleep(2);
            //触发block
            //submits its event handler block to its target queue.
            dispatch_source_merge_data(self.source, 1);
        });
    }
    
@end

总结

产生流

  dispatch_source_create

设置回调

  dispatch_source_set_event_handler

引发回调流、绑定source、带有data

  dispatch_source_merge_data

获取data

  dispatch_source_get_data

控制生命

  dispatch_resume
  dispatch_suspend