iOS多线程总结(2)——GCD的使用

本篇是多线程总结的第二篇，关于多线程的概念和NSThread的使用写在第一篇，查看请点击《iOS多线程总结(1)——多线程相关概念及NSObject/NSThread的使用》，本编主要讲解GCD的使用。

一. GCD简介

1. 什么是GCD

全称是Grand Central Dispatch，可译为“牛逼的中枢调度器”，纯C语言，提供了非常多非常强大的函数。

2. GCD的优势

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

3. GCD中两个核心概念

任务：执行什么操作
队列：用来存放任务

4. GCD的使用就三个步骤

创建自定义队列或获取系统的全局队列。
定制任务，即确定想做的事情。
使用GCD提供的同步函数或异步函数将任务添加到队列中。
即GCD底层会自动将队列中的任务取出，放到对应的线程中执行，任务的取出遵循队列的FIFO原则(先进先出，后进后出)。

5. GCD中执行任务的函数

用同步的方式执行任务

// queue：队列 block：任务
dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);
用异步的方式执行任务

// queue：队列 block：任务
dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
同步和异步的区别
- 同步：
  只能在当前线程中执行任务，不具备开启新线程的能力；
  在一个函数中添加任务，任务会顺序执行，且立马执行队列，执行完才返回来执行剩下的代码。
- 异步：
  可以在新的线程中执行任务，具备开启新线程的能力；
  在一个函数中添加任务，这个函数执行完，才返回执行子线程中的队列。

6. GCD用于存放任务的队列

并发队列（Concurrent Dispatch Queue），可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）并发功能只有在异步（dispatch_async）函数下才有效。
串行队列（Serial Dispatch Queue），让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）。

(1). 并发队列

GCD默认已经提供了全局的并发队列，供整个应用使用，不需要手动创建，使用 dispatch_get_global_queue 函数可获得全局的并发队列

// 函数原型：
// priority:队列的优先级
// flags:此参数暂时无用，用0即可
dispatch_queue_t dispatch_get_global_queue(dispatch_queue_priority_t priority, unsigned long flags); 

// 使用举例
// 获得全局并发队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); 

// 全局并发队列的优先级
#define DISPATCH_QUEUE_PRIORITY_HIGH 2 // 高
#define DISPATCH_QUEUE_PRIORITY_DEFAULT 0 // 默认（中）
#define DISPATCH_QUEUE_PRIORITY_LOW (-2) // 低
#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN // 后台

(2). 串行队列

GCD中获得串行有2种途径

使用dispatch_queue_create函数创建串行队列

// 函数原型：
// label:队列名称
// attr:队列属性，一般用NULL即可
dispatch_queue_t dispatch_queue_create(const char *label, dispatch_queue_attr_t attr);

// 使用举例
// 创建名字为ss_thread的串行队列
dispatch_queue_t queue = dispatch_queue_create(“ss_thread”, NULL); 
// 非ARC需要释放手动创建的队列
dispatch_release(queue);

使用主队列（跟主线程相关联的队列）

主队列是GCD自带的一种特殊的串行队列，放在主队列中的任务，都会放到主线程中执行，使用dispatch_get_main_queue()获得主队列。

//获得主队列
dispatch_queue_t queue = dispatch_get_main_queue();

7. 各种队列的执行效果

iOS多线程总结(2)——GCD的使用

代码举例：

#import "ViewController.h"

@interface ViewController ()

@end

@implementation ViewController

/** 触摸屏幕执行 */
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {

    [self syncConcurrent];
}

/**
 * 同步函数 + 并发队列：不会创建线程，会在“当前线程”执行任务，任务是串行的，执行完一个任务，再执行下一个任务。
 */
- (void)syncConcurrent {

// 1. 创建并发队列
// dispatch_queue_t queue = dispatch_queue_create("ss_Concurrent", DISPATCH_QUEUE_CONCURRENT);

// 1. 获取全局并发队列,DISPATCH_QUEUE_PRIORITY_DEFAULT:默认优先级
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

// 2. 通过同步函数添加任务到并发队列
// 任务1
dispatch_sync(queue, ^{

for (int i = 0; i < 10; i++) {
NSLog(@"%d----%@",i,[NSThread currentThread]);
        }
    });
// 任务2
dispatch_sync(queue, ^{

for (int i = 0; i < 10; i++) {
NSLog(@"%d----%@",i,[NSThread currentThread]);
        }
    });
// 任务3
dispatch_sync(queue, ^{

for (int i = 0; i < 10; i++) {
NSLog(@"%d----%@",i,[NSThread currentThread]);
        }
    });

}

/**
 * 同步函数 + 串行队列(主队列)
 */
- (void)syncMainSerial {

// 注意：
// 1. 如果当前线程是主线程，通过同步函数将任务添加到主队列，主线程就会陷入假堵塞状态，线程就会卡住不会往下执行。
// 2. 如果当前线程不是主线程，通过同步函数将任务添加到主队列，主线程会按顺序执行任务。

NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];

    [thread start];

}

// 线程任务
- (void)run {

// 1. 获取主队列
dispatch_queue_t queue = dispatch_get_main_queue();

// 2. 通过同步函数添加任务到主队列
// 任务1
dispatch_sync(queue, ^{

for (int i = 0; i < 10; i++) {
NSLog(@"%d----%@",i,[NSThread currentThread]);
        }
    });
// 任务2
dispatch_sync(queue, ^{

for (int i = 0; i < 10; i++) {
NSLog(@"%d----%@",i,[NSThread currentThread]);
        }
    });
// 任务3
dispatch_sync(queue, ^{

for (int i = 0; i < 10; i++) {
NSLog(@"%d----%@",i,[NSThread currentThread]);
        }
    });

}

/**
 * 同步函数 + 自定义串行队列：不会开启新的线程，在“当前线程”执行任务，任务是串行的，执行完一个任务，再执行下一个任务。
 */
- (void)syncCustomSerial {

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

// 2. 通过同步函数添加任务到串行队列
// 任务1
dispatch_sync(queue, ^{

for (int i = 0; i < 10; i++) {
NSLog(@"%d----%@",i,[NSThread currentThread]);
        }
    });
// 任务2
dispatch_sync(queue, ^{

for (int i = 0; i < 10; i++) {
NSLog(@"%d----%@",i,[NSThread currentThread]);
        }
    });
// 任务3
dispatch_sync(queue, ^{

for (int i = 0; i < 10; i++) {
NSLog(@"%d----%@",i,[NSThread currentThread]);
        }
    });

}

/**
 * 异步函数 + 串行队列(主队列)：不会开新线程，在主线程按任务的先后顺序执行。
 */
- (void)asyncMainSerial {

// 1. 获取主队列
dispatch_queue_t queue = dispatch_get_main_queue();

// 2. 使用异步函数将任务添加到主队列
// 任务1
dispatch_async(queue, ^{

for (int i = 0; i < 10; i++) {
NSLog(@"%d----%@",i,[NSThread currentThread]);
        }

    });
// 任务2
dispatch_async(queue, ^{

for (int i = 0; i < 10; i++) {
NSLog(@"%d----%@",i,[NSThread currentThread]);
        }

    });
// 任务3
dispatch_async(queue, ^{

for (int i = 0; i < 10; i++) {
NSLog(@"%d----%@",i,[NSThread currentThread]);
        }

    });

}

/**
 * 异步函数 + 自定义串行队列：会开启新的线程，但只开一条新线程，任务是一个执行完再到下一个执行，先进先出后进后出原则。
 */
- (void)asyncCustomSerial {

// 1. 创建一个串行队列
dispatch_queue_t queue = dispatch_queue_create("ss_serial", DISPATCH_QUEUE_SERIAL);

// 2. 使用异步函数将任务添加到串行队列
// 任务1
dispatch_async(queue, ^{

for (int i = 0; i < 10; i++) {
NSLog(@"%d----%@",i,[NSThread currentThread]);
        }

    });
// 任务2
dispatch_async(queue, ^{

for (int i = 0; i < 10; i++) {
NSLog(@"%d----%@",i,[NSThread currentThread]);
        }

    });
// 任务3
dispatch_async(queue, ^{

for (int i = 0; i < 10; i++) {
NSLog(@"%d----%@",i,[NSThread currentThread]);
        }
    });

}

/**
 * 异步函数 + 并发队列：可以开启多条线程，并发执行。
 */
- (void)asyncConcurrent {

// 1. 创建一个并发队列
// dispatch_queue_t queue = dispatch_queue_create("ss_queue", DISPATCH_QUEUE_CONCURRENT);

// 1. 获取全局并发队列,DISPATCH_QUEUE_PRIORITY_DEFAULT:默认优先级
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

// 2. 使用异步函数将任务添加到并发队列
// 任务1
dispatch_async(queue, ^{

for (int i = 0; i < 10; i++) {
NSLog(@"%d----%@",i,[NSThread currentThread]);
        }

    });
// 任务2
dispatch_async(queue, ^{

for (int i = 0; i < 10; i++) {
NSLog(@"%d----%@",i,[NSThread currentThread]);
        }

    });
// 任务3
dispatch_async(queue, ^{

for (int i = 0; i < 10; i++) {
NSLog(@"%d----%@",i,[NSThread currentThread]);
        }

    });

}

@end

二. 线程通信

1. 从子线程回到主线程

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

2. 从子线程传到子线程再传到主线程

- (void)communication {
// 1. 创建一个串行队列
dispatch_queue_t queue1 = dispatch_queue_create("serial_one", DISPATCH_QUEUE_SERIAL);
// 2. 使用异步函数把任务添加到队列
dispatch_async(queue1, ^{

// 1. 创建url
NSURL *url = [NSURL URLWithString:@"http://img.51ztzj.com/upload/image/20140917/sj201409171024_279x419.jpg"];

// 2. 下载图片数据
        NSData *data = [NSData dataWithContentsOfURL:url];

// 3. 生成图片
UIImage *imageOne = [UIImage imageWithData:data];

NSLog(@"%@",[NSThread currentThread]);


// 3. 线程通信,子线程传给子线程
// 3.1 创建一个串行队列
dispatch_queue_t queue2 = dispatch_queue_create("serial_two", DISPATCH_QUEUE_SERIAL);
// 3.2 使用异步函数把任务添加到队列
dispatch_async(queue2, ^{

UIImage *imageTwo = imageOne;
NSLog(@"%@",[NSThread currentThread]);


// 3.3 线程通信，把图片传回主线程
dispatch_async(dispatch_get_main_queue(), ^{

self.imageView.image = imageTwo;
NSLog(@"%@",[NSThread currentThread]);
            });

        });

    });
}

三. 延时执行/线程栅栏

注意：

延迟执行不等于线程堵塞，不能通过sleepUntilDate:方法和sleepForTimeInterval:方法设置延迟。
线程栅栏的使用必须用在自定义的队列中才起作用，在全局队列中不起作用。

具体代码：

#import "ViewController.h"

@interface ViewController ()

// 开始时间
@property (nonatomic, assign) double begin;
// 结束时间
@property (nonatomic, assign) __block double end;

@end

@implementation ViewController

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

    _begin = [NSDate timeIntervalSinceReferenceDate];

// 延迟执行方式1
// 延迟3秒执行
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{

        _end = [NSDate timeIntervalSinceReferenceDate];
NSLog(@"时间间隔为%f秒",_end - _begin);
    });

// 延迟执行方式2
// 延迟2.5秒执行
// TimeInterval:延迟执行时间
// repeats:是否重复执行
// [NSTimer scheduledTimerWithTimeInterval:2.5 target:self selector:@selector(run) userInfo:nil repeats:NO];

// 延迟执行方式3
// 延迟5秒执行
// afterDelay:延迟执行时间
    [self performSelector:@selector(run) withObject:nil afterDelay:0];

// 提示：performSelector:withObject:afterDelay:和NSTimer的延迟都是通过NSRunLoop实现的。
// 注意：延迟执行不等于线程堵塞，不同通过sleepUntilDate:方法和sleepForTimeInterval:方法设置延迟。

}

- (void)run {

    _end = [NSDate timeIntervalSinceReferenceDate];
NSLog(@"时间间隔为%f秒",_end - _begin);


// 1. 创建一个并发队列
// dispatch_queue_t queue = dispatch_queue_create("ss_concurrent", DISPATCH_QUEUE_CONCURRENT);
// 1. 获取全局并发队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

// 2. 使用异步函数把任务添加到并发队列
// 任务1
dispatch_async(queue, ^{

for (int i = 0; i < 10; i++) {
NSLog(@"%d----%@",i,[NSThread currentThread]);
        }
    });
// 任务2
dispatch_async(queue, ^{

for (int i = 0; i < 10; i++) {
NSLog(@"%d----%@",i,[NSThread currentThread]);
        }
    });


// 线程栅栏
// 注意：线程栅栏的使用必须用在自定义的队列中才起作用，在全局队列中不起作用。
    dispatch_barrier_async(queue, ^{

NSLog(@"------------------------------------");
    });


// 任务3
dispatch_async(queue, ^{

for (int i = 0; i < 10; i++) {
NSLog(@"%d----%@",i,[NSThread currentThread]);
        }
    });
// 任务4
dispatch_async(queue, ^{

for (int i = 0; i < 10; i++) {
NSLog(@"%d----%@",i,[NSThread currentThread]);
        }
    });

}

@end

四. 队列组

注意：
一定要注意函数的使用，必须是关于组队列的函数配合使用，例如：dispatch_group_async()函数和dispatch_group_notify()函数的配合，不能是是dispatch_async()函数和dispatch_group_notify()函数的配合。

具体代码：图片合成

#import "ViewController.h"

@interface ViewController ()

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

@property (nonatomic, strong) UIImage *image1;

@property (nonatomic, strong) UIImage *image2;

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];

// 1. 创建一个并发队列
dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
// 2. 创建一个组队列
    dispatch_group_t group = dispatch_group_create();

// 3. 下载第一张相片
// 通过异步函数把任务添加到并发队列
    dispatch_group_async(group, queue, ^{

NSURL *url = [NSURL URLWithString:@"http://www.bz55.com/uploads/allimg/150429/140-1504291Z502-50.jpg"];
        NSData *data = [NSData dataWithContentsOfURL:url];
        _image1 = [UIImage imageWithData:data];
    });

// 4. 下载第二张相片
// 通过异步函数把任务添加到并发队列
    dispatch_group_async(group, queue, ^{

NSURL *url = [NSURL URLWithString:@"http://img.taopic.com/uploads/allimg/110914/8879-11091422541844.jpg"];
        NSData *data = [NSData dataWithContentsOfURL:url];
        _image2 = [UIImage imageWithData:data];
    });


// 5. 合成相片
    dispatch_group_notify(group, queue, ^{

CGSize size = self.view.bounds.size;

// 开启新的图像上下文
        UIGraphicsBeginImageContext(size);

// 画图
        [_image1 drawInRect:CGRectMake(0, 0, size.width, size.height * 0.5)];
        [_image2 drawInRect:CGRectMake(0, size.height * 0.5, size.width, size.height * 0.5)];

// 获取图片
UIImage *image = UIGraphicsGetImageFromCurrentImageContext();

// 结束图像上下文
        UIGraphicsEndImageContext();

// 回到主线程显示图片
// 注意，不要再子线程设置UI界面，可能会出错
dispatch_async(dispatch_get_main_queue(), ^{
// 设置图片
            _imageView.image = image;
        });

    });

}

@end

五. 快速遍历

使用注意：遍历的对象必须是互不相干的，没有联系的对象。
函数原型：

// iterations:遍历总数
// queue:队列
// size_t:索引的类型，需要索引，可以在使用的时候添加一个变量：如^(size_t index){}
void dispatch_apply(size_t iterations, dispatch_queue_t queue, void (^block)(size_t));

具体使用：文件剪切

#import "ViewController.h"

@interface ViewController ()

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];

// 获取一个全局并发队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

// 文件夹路径
NSString *from = @"/Users/SJM/Desktop/From";
NSString *to = @"/Users/SJM/Desktop/To";

// 获取文件管理员
NSFileManager *manager = [NSFileManager defaultManager];
// 获取所有文件夹中的文件路径
NSArray *pathArr = [manager subpathsAtPath:from];

// 快速遍历
    dispatch_apply(pathArr.count, queue, ^(size_t index) {

// 获取文件路径
NSString *path = pathArr[index];

// 拼接路径
NSString *fromPath = [from stringByAppendingPathComponent:path];
NSString *toPath = [to stringByAppendingPathComponent:path];

// 剪切
        [manager moveItemAtPath:fromPath toPath:toPath error:nil];

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

@end

六. 一次性代码

使用dispatch_once函数能保证某段代码在程序运行过程中只被执行1次

使用举例：

static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
// 只执行1次的代码(这里面默认是线程安全的)
});

函数解析：

  // dispatch_once_t实质是long的宏定义，定义的变量用于检查该代码块是否已经被调度，用于dispatch_once()函数
static dispatch_once_t onceToken;

// 声明一个Block变量，用于存储只执行1次的代码
void (^block)() = ^{
// 只执行1次的代码(这里面默认是线程安全的)
  };

// dispatch_once()函数接收一个检查代码块是否已执行的变量和一个希望在应用的生命周期内仅被调度一次的代码块；
// dispatch_once不仅意味着代码仅会被运行一次，而且还是线程安全的，如果被多个线程调用，该函数会同步等待直至代码块完成。
dispatch_once(&onceToken,block);

七. 定时器

GCD的定时器与NSRunLoop的运行模式没有关系，即NSRunLoop的运行模式不管是NSDefaultRunLoopMode或者是UITrackingRunLoopMode，GCD定时器都会执行。

具体使用：

#import "ViewController.h"

@interface ViewController ()

@property (nonatomic, strong) dispatch_source_t timer;

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];

// 创建定时器,(dispatch_source_t本质是OC对象)
self.timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, dispatch_get_main_queue());

// 设置定时器的实践参数，时间参数一般是纳秒（1秒 == 10的9次方纳秒）为单位
// 何时开始
    dispatch_time_t start = dispatch_time(DISPATCH_TIME_NOW, (ino64_t)(1.0 * NSEC_PER_SEC));
// 时间间隔
    uint64_t interval = (uint64_t)(2.0 * NSEC_PER_SEC);
// 设置参数
    dispatch_source_set_timer(self.timer, start, interval, 0);

// 设置回调，即设置需要定时器定时执行的操作
    dispatch_source_set_event_handler(self.timer, ^{

NSLog(@"------");

    });

// 启动定时器
    dispatch_resume(self.timer);

}

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

// 取消定时器
    dispatch_cancel(self.timer);
self.timer = nil;
}

@end

秒客网

iOS多线程总结(2)——GCD的使用

一. GCD简介

1. 什么是GCD

2. GCD的优势

3. GCD中两个核心概念

4. GCD的使用就三个步骤

5. GCD中执行任务的函数

6. GCD用于存放任务的队列

7. 各种队列的执行效果

二. 线程通信

1. 从子线程回到主线程

2. 从子线程传到子线程再传到主线程

三. 延时执行/线程栅栏

四. 队列组

五. 快速遍历

六. 一次性代码

七. 定时器

相关文章