//1.创建串行或变行队列
//创建串行或变行队列
- (void)createDispatchQueue
{
//法1 dispatch_queue_create (NULL,默认是串行)
dispatch_queue_t myConcurrentDispatchQueue = dispatch_queue_create("com.tzyj.myConcurrentDispatchQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(myConcurrentDispatchQueue, ^{NSLog(@"block on myConcurrentDispatchQueue");});//block会持有改队列，所以下面释放队列没有任何影响
dispatch_release(myConcurrentDispatchQueue);//ARC也要， 因为ARC下也没有DispatchQueue管理
{//法1补充 队列优先级修改
//dispatch_queue_create创建的队列默认是DISPATCH_QUEUE_PRIORITY_DEFAULT，如何修改优先级 如DISPATCH_QUEUE_PRIORITY_BACKGROUND
dispatch_queue_t mySerialDispatchQueue = dispatch_queue_create("com.tzyj.mySerialDispatchQueue", NULL);
dispatch_queue_t globalDispatchQueueBackground = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
dispatch_set_target_queue(mySerialDispatchQueue, globalDispatchQueueBackground);
}
//法2 用系统标准获取Dispatch Queue, 不用自己release
//主线程队列 串行队列
dispatch_queue_t mainDispatchQueue = dispatch_get_main_queue();
//global队列 并行队列
dispatch_queue_t globalDispatchQueueHigh = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_queue_t globalDispatchQueueDefault = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_queue_t gl0balDispatchQueueLow = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);
dispatch_queue_t gl0balDispatchQueueBackground = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
//常用gcd框架
//global dispatch queue 中执行block
dispatch_async(globalDispatchQueueDefault, ^{
//可并行处理的操作
//main dispatch queue中执行block
dispatch_async(mainDispatchQueue, ^{
//只能在主线程执行的处理
});
});
}
//2.延迟执行和特定时间执行
//2.延迟执行和特定时间执行
dispatch_time_t getDispatchTimeByDate(NSDate *date); //C语言函数原型申明
- (void)testGCDTime
{
//相对时间 3s后开始追加任务到block dispatch_after 指定时间后追加处理到dispatch queue中，并不是马上执行处理。
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"waited at least 3 seconds");
});
//绝对时间 20221009 11：11：11
NSDateFormatter *dateFormatter=[[NSDateFormatter alloc]init];
[dateFormatter setDateFormat:@"yyyyMMddHHmmss"];
[dateFormatter setTimeZone:[NSTimeZone localTimeZone]];
NSDate *date=[dateFormatter dateFromString:@"20221009111111"];
dispatch_time_t absolutTime = getDispatchTimeByDate(date);
dispatch_after(absolutTime, dispatch_get_main_queue(), ^{
NSLog(@"absolute time");
});
}
//c语言 获取绝对时间 dispatch_walltime
dispatch_time_t getDispatchTimeByDate(NSDate *date)
{
NSTimeInterval interval;
double second,subsecond;
struct timespec time;
dispatch_time_t milestone;
interval = [date timeIntervalSince1970];
subsecond = modf(interval, &second);
time.tv_sec = second;
time.tv_nsec = subsecond * NSEC_PER_SEC;
milestone = dispatch_walltime(&time, 0);
return milestone;
}
3.//多个任务都结束后再执行其它任务，用dispatch_group_
- (void)testDispatchGroup
{
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, queue, ^{
NSLog(@"blk0");
});
dispatch_group_async(group, queue, ^{
NSLog(@"blk1");
});
dispatch_group_async(group, queue, ^{
NSLog(@"blk2");
});
if(1)//法1
{
dispatch_group_notify(group, queue, ^{
NSLog(@"all done");
});
}
else if(2)//法2
{
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);//永远等待，最好不要子啊主线程上这种用，会有卡死情况出现
}
else if(21)//法2 用法2 超时机制<eg超时3s>
{
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC));
long result = dispatch_group_wait(group, time);
if (result == 0) {
NSLog(@"all done");
} else {
NSLog(@"还有没有执行完成的");
}
}
dispatch_release(group); //如果是在OS X 10.8或iOS 6以及之后版本中使用，Dispatch Group将会由ARC自动管理，如果是在此之前的版本，需要自己手动释放。
}
4.//数据库读写，避免数据竞争问题思想， dispatch_barrier_sync
//思想 读操作可以并行处理，追加到并行队列(concurrent dispatch queue); //没有任何读的操作下，将写处理追加到串行队列，写没处理完之前 不可以读
//法2 dispatch_barrier_sync(//法1 用dispatch group和dispatch_set_target_queue实现)
- (void)testDispatchBarrierAsync
{
//并行队列 读操作可以并行处理
dispatch_queue_t queue = dispatch_queue_create("com.tzyj.forBarrier", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{NSLog(@"blk0_for_reading");}); //读
dispatch_async(queue, ^{NSLog(@"blk1_for_reading");});
dispatch_async(queue, ^{NSLog(@"blk2_for_reading");});
dispatch_async(queue, ^{NSLog(@"blk3_for_reading");});
//dispatch_barrier_sync函数会等待追加到并行队列queue的任务全部处理结束后，在将指定的任务（blk_for_writing）追加到并行队列queue中，等任务（blk_for_writing）结束后，并行队列queue恢复为一般的动作。
dispatch_barrier_sync(queue, ^{
NSLog(@"blk_for_writing"); //写
});
dispatch_async(queue, ^{NSLog(@"blk4_for_reading");});
dispatch_async(queue, ^{NSLog(@"blk5_for_reading");});
dispatch_async(queue, ^{NSLog(@"blk6_for_reading");});
dispatch_async(queue, ^{NSLog(@"blk7_for_reading");});
}
5.注意以下死锁情况
Paste_Image.png
6.重复追加block 到队列中
//法2 dispatch_barrier_sync(//法1 用dispatch group和dispatch_set_target_queue实现)
- (void)testDispatchBarrierAsync
{
//并行队列 读操作可以并行处理
dispatch_queue_t queue = dispatch_queue_create("com.tzyj.forBarrier", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{NSLog(@"blk0_for_reading");}); //读
dispatch_async(queue, ^{NSLog(@"blk1_for_reading");});
dispatch_async(queue, ^{NSLog(@"blk2_for_reading");});
dispatch_async(queue, ^{NSLog(@"blk3_for_reading");});
//dispatch_barrier_sync函数会等待追加到并行队列queue的任务全部处理结束后，在将指定的任务（blk_for_writing）追加到并行队列queue中，等任务（blk_for_writing）结束后，并行队列queue恢复为一般的动作。
dispatch_barrier_sync(queue, ^{
NSLog(@"blk_for_writing"); //写
});
dispatch_async(queue, ^{NSLog(@"blk4_for_reading");});
dispatch_async(queue, ^{NSLog(@"blk5_for_reading");});
dispatch_async(queue, ^{NSLog(@"blk6_for_reading");});
dispatch_async(queue, ^{NSLog(@"blk7_for_reading");});
}
7.//更新数据时候，如果并行处理会导致数据不一致，有时程序还会异常结束，
//解决:通过信号机制dispatch_semaphore_ 可以保证更新数据的时候只有一个线程在执行
-(void)testDispatchSemaphore
{
dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);//保证只有一个线程
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)); //最多等待3s；
long result = dispatch_semaphore_wait(semaphore, time);
if (result == 0) {
//在规定的待机时间内 dispatch semaphore信号计数值大于等于1，所有信号计数减1
//可以执行排他的控制处理
}else{
//由于信号值为0，所以在指定时间内一直待机
}
dispatch_release(semaphore);
//常用场景：更新数组数据
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//生成dispatch semaphore,初始值为1，保证可访问数组对象的线程同时只能有1个
semaphore = dispatch_semaphore_create(1);
NSMutableArray *array = [[NSMutableArray alloc] init];
for(int i=0; i<10000; i++)
{
dispatch_async(queue, ^{
//一直等待dispatch semaphore信号计数值大于等于1
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
//由于初始为1，信号值减1，dispatch_semaphore_wait函数返回
//此时信号计算值为0， 其他线程都只能等待， 只有一个线程访问，所以可以安全更新数据
[array addObject:[NSNumber numberWithInt:i]];
//排他控制结束后， 需要其他线程（通过dispatch_semaphore_wait函数）也执行，需要将信号值加1
dispatch_semaphore_signal(semaphore);
});
}
dispatch_release(semaphore);
}
8.dispatch_once 保证函数在应用程序里只执行一直
多线程环境下和安全
-(void)testDispatchOnce
{
//老方法 在多线程环境可能会执行多次
static int initialized = NO;
if (initialized == NO) {
//初始化动作
initialized = YES;
}
//以后尽量用下面的方法替换上面的逻辑
//用dispatch_once 多线程下也安全
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
//初始化
});
}
//单例模式 推荐用上面第一种
+ (HsOptionTQuoteDataModel *)sharedManager
{
static HsOptionTQuoteDataModel *sharedInstance = nil;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
sharedInstance = [[self alloc] init];
});
return sharedInstance;
}
static HsConfigration *sharedSingletonManager = nil;
+ (HsConfigration *)sharedManager
{
@synchronized(self) {
if (sharedSingletonManager == nil) {
sharedSingletonManager = [[self alloc] init]; // assignment not done here
}
}
return sharedSingletonManager;
}
9.含block的自定义网络回调接口
Paste_Image.png
如果你发现本文对你有所帮助，如果你认为其他人也可能受益，请把它分享出去。
