ios多线程操作— GCD延迟操作和相关使用方法
0x01.iOS版本
使用GCD函数可以进行延时操作，该函数为
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delayInSeconds * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
});
现在我们来分解一下参数
dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delayInSeconds * NSEC_PER_SEC)) ： NSEC_PER_SEC
在头文件中的定义如下：
#define NSEC_PER_SEC 1000000000ull /* nanoseconds per second */
该参数表示从现在开始经过多少纳秒
dispatch_get_main_queue()：表示主队列. ^{ }：表示一个block任务。
我们可以来测试一下经过多少纳秒之后，由主队列调度任务是异步执行还是同步执行，代码如下：
// when 时间 从现在开始经过多少纳秒
dispatch_time_t when = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC));
void (^task)() = ^ {
// 延迟操作执行的代码
NSLog(@"%@", [NSThread currentThread]);
};
// 经过多少纳秒，由主队列调度任务异步执行
dispatch_after(when, dispatch_get_main_queue(), task);
// 先执行就是异步，后执行就是同步
NSLog(@"come here");
由此可见主队列中调度任务是异步执行的 再将执行队列改为全局队列和串行队列，得到的结果完全是一样的，由此可知该函数执行的是异步操作。
GCD中有个函数能够保证某段代码在程序运行过程中只被执行1次！该函数如下：
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
})
dispatch_once_t在头文件中得定义如下：typedef long dispatch_once_t; 由此可知该类型是个long类型。当onceToken等于0时就会执行block代码。dispatch_once是线程安全的，只要涉及到线程安全就会涉及到锁，dispatch_once内部也有一把锁，性能比互斥锁高！ 利用该函数我们可以来写一个单例模式 单例模式可以保证在程序运行过程，一个类只有一个实例且该实例易于供外界访问，从而方便控制实例个数，并节约系统资源，当应用程序需要共享一份资源时就可以用单例模式来实现。单例模式分ARC与MRC两种情况，我们可以用宏判断是否为ARC环境
#if __has_feature(objc_arc)
// ARC
#else
// MRC
#endif
ARC环境下简单地单例模式：
@implementation SoundTools
// 定义一个静态成员，保存唯一的实例
static id instance;
// 保证对象只被分配一次内存空间，通过dispatch_once能够保证单例的分配和初始化是线程安全的
+ (instancetype)allocWithZone:(struct _NSZone *)zone {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
instance = [super allocWithZone:zone];
});
return instance;
}
// 保证对象只被初始化一次
+ (instancetype)sharedSoundTools {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
instance = [[self alloc] init];
});
return instance;
}
- (id)copyWithZone:(NSZone *)zone {
return instance;
}
@end
测试代码如下：
- (void)viewDidLoad {
[super viewDidLoad];
SoundTools *s1 = [SoundTools sharedSoundTools];
NSLog(@"%p", s1);
}
- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
SoundTools *s2 = [SoundTools sharedSoundTools];
NSLog(@"%p", s2);
}
两个方法打印出来的地址完全一样！
在MRC环境下有如下代码：
// 定义一个静态成员，保存唯一的实例
static id instance;
// 保证对象只被分配一次内存空间，通过dispatch_once能够保证单例的分配和初始化是线程安全的
+ (instancetype)allocWithZone:(struct _NSZone *)zone {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
instance = [super allocWithZone:zone];
});
return instance;
}
// 保证对象只被初始化一次
+ (instancetype)sharedSoundTools {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
instance = [[self alloc] init];
});
return instance;
}
- (id)copyWithZone:(NSZone *)zone {
return instance;
}
#pragma mark - MRC内存管理方法
/**
因为单例的对象是保存在静态区的，因此需要重写 内存管理方法，取消默认的引用计数操作！
*/
// 默认会将引用计数－1
- (oneway void)release {
// 什么也不做，跟highlight类似
}
// 默认引用计数＋1，同时返回一个对象
- (instancetype)retain {
return instance;
}
// 默认添加自动释放标记，延迟释放！
- (instancetype)autorelease {
return instance;
}
// 返回有多少个对象对当前对象引用的数值
- (NSUInteger)retainCount {
// 出处：limits.h 会根据CPU的架构自行调整整数的长度
return ULONG_MAX;
}
0x02.swift 3.0版本
1.延迟执行：
DispatchQueue.main.asyncAfter(deadline: DispatchTime.now()+3.0, execute: {
[unowned self] () -> Void in
//延迟操作
})
PS. DispatchTime对象用now()获取当前时间，加上秒数即可
2.全局队列执行耗时操作后切换到主线程刷新UI
DispatchQueue.global().async {
// 耗时操作
DispatchQueue.main.async {
// 主线程刷新UI
}
}
3.同步执行操作
DispatchQueue.global().sync {
// 同步执行
}
4.创建队列
DispatchQueue的默认初始化方法创建的是同步队列，如果要创建并发的队列，在attributes中声明.concurrent。
// 同步队列
let serialQueue = DispatchQueue(label: "name")
// 并发队列
let concurrentQueue = DispatchQueue(label: "name", attributes: .concurrent)
5.执行多个任务后再做某种操作
使用DispatchGroup，所有操作都完成后执行notify。
let group = DispatchGroup()
let queue1 = DispatchQueue(label: "queue1")
queue1.async(group: group) {
// 执行任务1
}
let queue2 = DispatchQueue(label: "queue2")
queue1.async(group: group) {
// 执行任务2
}
group.notify(queue: DispatchQueue.main) {
// 执行完成
}
如果要在某一任务或某几个任务后后执行其他任务，可在任务间加上等待：
//等待组内任务全部完成
group.wait(timeout: DispatchTime.distantFuture)
6.DispatchWorkItem的使用
- DispatchWorkItem可理解为任务条目，可初始化传入优先级等参数，因其有默认值，也可只传入一个闭包。同样，它也有wait方法，使用和上面差不多。
let queue = DispatchQueue(label: "queue", attributes: .concurrent)
let workItem = DispatchWorkItem {
// 任务
}
queue.async(execute: workItem)
print("before waiting")
workItem.wait()
print("after waiting")
7.barrier栅栏
- barrier的加入会等到在它加入队列之前的“任务”执行完毕后，才开始执行。在它之后加入队列的“任务”，则等到这个“任务”执行完毕后才开始执行。这里的“任务”用DispatchWorkItem创建。
let barrierWorkItem = DispatchWorkItem(flags: .barrier) {
// 栅栏操作，比如之前有若干“读”操作，这里有“写”操作
}
let queue = DispatchQueue(label: "queue", attributes: .concurrent)
queue.async(execute: barrierWorkItem)
8.信号量
为了线程安全的统计数量，会使用信号量作计数。初始化方法只有一个，传入一个Int类型的数。
let semaphore = DispatchSemaphore(value: 10)
// 信号量减一
semaphore.wait()
// 信号量加一
semaphore.signal()
