OC底层原理 - 21 NSThread&GCD& NSOperation

本文的主要目的是介绍NSThreadGCDNSOperation常见的使用方式。

NSThread

NSthread是苹果官方提供面向对象的线程操作技术,是对thread的上层封装,比较偏向于底层。简单方便,可以直接操作线程对象,使用频率较少。它需要程序员自己管理线程的生命周期。

NSThread的使用如下

  • 通过init初始化方式创建
//方式1
- (instancetype)initWithTarget:(id)target selector:(SEL)selector object:(nullable id)argument API_AVAILABLE(macos(10.5), iOS(2.0), watchos(2.0), tvos(9.0));
//示例
NSThread* thread1 = [[NSThread alloc] initWithTarget:self selector:@selector(doSomething:) object:@"方式1"];
[thread1 start];

//方式2
- (instancetype)initWithBlock:(void (^)(void))block API_AVAILABLE(macosx(10.12), iOS(10.0), watchos(3.0), tvos(10.0));
//示例
self.thread1 = [[NSThread alloc] initWithBlock:^{
    NSLog(@"%@",[NSThread currentThread]);
}];
[self.thread1 start];
  • 通过detachNewThread(xxx)构造器方式创建
//方式1
+ (void)detachNewThreadSelector:(SEL)selector toTarget:(id)target withObject:(nullable id)argument;
//示例
[NSThread detachNewThreadSelector:@selector(doSomething:) toTarget:self withObject:@"方式1"];

//方式2
+ (void)detachNewThreadWithBlock:(void (^)(void))block API_AVAILABLE(macosx(10.12), iOS(10.0), watchos(3.0), tvos(10.0));
//示例
[NSThread detachNewThreadWithBlock:^{
    NSLog(@"%@", [NSThread currentThread]);
}];
  • 通过performSelector(xxx)方式创建
//在主线程执行
- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(nullable id)arg waitUntilDone:(BOOL)wait modes:(nullable NSArray *)array;
- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(nullable id)arg waitUntilDone:(BOOL)wait;
//示例
[self performSelectorOnMainThread:@selector(doSomething:) withObject:@"方式3" waitUntilDone:YES modes:@[NSRunLoopCommonModes]];
[self performSelectorOnMainThread:@selector(doSomething:) withObject:@"方式3" waitUntilDone:YES];

//在指定线程执行
- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thr withObject:(nullable id)arg waitUntilDone:(BOOL)wait modes:(nullable NSArray *)array API_AVAILABLE(macos(10.5), iOS(2.0), watchos(2.0), tvos(9.0));
- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thr withObject:(nullable id)arg waitUntilDone:(BOOL)wait API_AVAILABLE(macos(10.5), iOS(2.0), watchos(2.0), tvos(9.0));
//示例
[self performSelectorOnMainThread:@selector(doSomething:) withObject:@"方式3" waitUntilDone:YES];
[self performSelector:@selector(doSomething:) onThread:[NSThread currentThread] withObject:@"方式3" waitUntilDone:YES modes:@[NSRunLoopCommonModes]];

//创建一个子线程执行
- (void)performSelectorInBackground:(SEL)aSelector withObject:(nullable id)arg API_AVAILABLE(macos(10.5), iOS(2.0), watchos(2.0), tvos(9.0));
//示例
[self performSelectorInBackground:@selector(doSomething:) withObject:@"方式3"];

NSThread的属性

  • 以下属性用于表示当前线程的状态
//表示线程是否正在执行
@property (readonly, getter=isExecuting) BOOL executing;
//表示线程是否执行完成
@property (readonly, getter=isFinished) BOOL finished;
//线程是否被取消
@property (readonly, getter=isCancelled) BOOL cancelled;
  • 线程优先级
/** NSQualityOfService:
  NSQualityOfServiceUserInteractive:最高优先级,主要用于提供交互UI的操作,比如处理点击事件,绘制图像到屏幕上
  NSQualityOfServiceUserInitiated:次高优先级,主要用于执行需要立即返回的任务
  NSQualityOfServiceDefault:默认优先级,当没有设置优先级的时候,线程默认优先级
  NSQualityOfServiceUtility:普通优先级,主要用于不需要立即返回的任务
  NSQualityOfServiceBackground:后台优先级,用于完全不紧急的任务
*/
@property NSQualityOfService qualityOfService; // read-only after the thread is started

+ (double)threadPriority;
  • 线程名称
@property (nullable, copy) NSString *name;
  • 线程使用栈区大小,默认是512K
@property NSUInteger stackSize;
  • 线程调用栈信息
//该线程中函数调用的虚拟地址的数组
@property (class, readonly, copy) NSArray *callStackReturnAddresses;
//线程调用函数的名字数字
@property (class, readonly, copy) NSArray *callStackSymbols;
  • 判断是否主线程或者获取当前
//是否是主线程
@property (readonly) BOOL isMainThread;
@property (class, readonly) BOOL isMainThread; // reports whether current thread is main

//获取主线程
@property (class, readonly, strong) NSThread *mainThread;

//获取当前线程
@property (class, readonly, strong) NSThread *currentThread;

实例方法

  • 线程启动,实例化的线程需要手动启动,此时线程进入就绪状态
- (void)start;

NSThread* thread = [[NSThread alloc] initWithTarget:self selector:@selector(doSomething:) object:@"方式1"];
[thread start];
  • 线程取消。调用-cancel方法并不会立刻取消线程,它仅仅是将cancelled属性设置为YES。cancelled也仅仅是一个用于记录状态的属性。线程取消的功能需要我们在main函数中自己实现
- (void)cancel;

[thread cancel];
  • 如果创建NSThread时不指定target或者selector,那么main函数就会直接推出,如果都指定了,main函数会调用[target selector:argument],执行完成后退出。当调用start时,start方法内部调用的就是main方法
- (void)main;   // thread body method

[thread main];

类方法

  • 线程阻塞(暂停)
+ (void)sleepUntilDate:(NSDate *)date;
+ (void)sleepForTimeInterval:(NSTimeInterval)ti;
  • 强制停止线程,线程进入死亡状态。该方法属于核弹级别终极API,调用之后会立即终止线程,即使任务还没有执行完成也会中断。这就非常有可能导致内存泄露等严重问题,所以一般不推荐使用
+ (void)exit;
  • 设置线程调度优先级 priority(优先级)。调度优先级的取值范围是0.0 - 1.0默认0.5,值越大,优先级越高。
+ (double)threadPriority;
+ (BOOL)setThreadPriority:(double)p;

GCD

dispatch_after函数

dispatch_after能让我们添加进队列的任务延时执行,该函数并不是在指定时间后执行处理,而只是在指定时间后追加处理到dispatch_queue

/*
参数1 when:任务在何时开始执行
参数2 queue:执行任务的队列
参数3 block:需要执行的任务
*/
void
dispatch_after(dispatch_time_t when, dispatch_queue_t queue, dispatch_block_t block);
        
//示例
dispatch_queue_t queue = dispatch_queue_create("hqThread", DISPATCH_QUEUE_SERIAL);
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 2*NSEC_PER_SEC), queue, ^{
    NSLog(@"test dispatch_after");
});

dispatch_once函数

dispatch_once保证在App运行期间,block中的代码只执行一次。多用于创建单例的情况。

重点:dispatch_once是线程安全的。

/*
参数1 predicate:用于检查该代码块是否已经被调度的谓词,虽然它是一个长整形,但是它是作为BOOL使用,且当值超过
参数2 block:需要执行的任务
*/
void
dispatch_once(dispatch_once_t *predicate, DISPATCH_NOESCAPE dispatch_block_t block);

//示例
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
    NSLog(@"创建单例");
});

dispatch_apply函数

该函数按指定的次数将指定的Block追加到指定的Dispatch Queue中,并等待全部处理执行结束。

注意:该函数是需要等待全部任务执行完成之后再继续函数后面的操作,效果与dispatch_sync类似,因此,在指定执行任务的线程时,需要防止死锁。

/*
参数1 iterations:指定任务执行的次数
参数2 queue:执行任务的线程
参数3 block:需要执行的任务,该block有个入参,表示当前是第几次执行
*/
void
dispatch_apply(size_t iterations,
        dispatch_queue_t DISPATCH_APPLY_QUEUE_ARG_NULLABILITY queue,
        DISPATCH_NOESCAPE void (^block)(size_t));

//示例
dispatch_apply(3, dispatch_queue_create("hqThread", DISPATCH_QUEUE_CONCURRENT), ^(size_t a) {
    NSLog(@"[%zu] current thread:%@", a, [NSThread currentThread]);
});

dispatch_group_t 任务组

它的主要用于监听管理任务组中任务完成情况。与dispatch_group_notify函数配合,可以在任务完成后做一些操作处理。

常用方法如下:

// 创建一个任务组
dispatch_group_t dispatch_group_create(void);

// 将任务添加到任务组里,并且异步执行
void dispatch_group_async(dispatch_group_t group, dispatch_queue_t queue, dispatch_block_t block);

// 表示接下来手动向任务组添加任务,即任务组中的任务数+1
void dispatch_group_enter(dispatch_group_t group);

// 任务组中任务数-1与dispatch_group_enter必须成对出现
void dispatch_group_leave(dispatch_group_t group);

// 等待之前任务执行完成后才继续执行
intptr_t dispatch_group_wait(dispatch_group_t group, dispatch_time_t timeout);

// 当任务组中任务完成,会出发出发此方法的block
void dispatch_group_notify(dispatch_group_t group, dispatch_queue_t queue, dispatch_block_t block);

接下来分别通过示例来说任务组的使用进行说明。

dispatch_group_t group = dispatch_group_create();
dispatch_queue_t queue = dispatch_queue_create("hqThread", DISPATCH_QUEUE_SERIAL);
    
dispatch_group_async(group, queue, ^{
    [NSThread sleepForTimeInterval:2];
    NSLog(@"[任务1] %@", [NSThread currentThread]);
});
    
dispatch_group_enter(group);
dispatch_async(queue, ^{
    [NSThread sleepForTimeInterval:2];
    NSLog(@"[任务2] %@", [NSThread currentThread]);
});
    
dispatch_async(queue, ^{
    [NSThread sleepForTimeInterval:2];
    NSLog(@"[任务3] %@", [NSThread currentThread]);
    dispatch_group_leave(group);
});

dispatch_async(queue, ^{
    NSLog(@"wait start");
    dispatch_group_wait(group, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC*6));
    NSLog(@"wait end");
});
    
dispatch_async(queue, ^{
    [NSThread sleepForTimeInterval:4];
    NSLog(@"[任务4] %@", [NSThread currentThread]);
});
    
dispatch_group_notify(group, queue, ^{
    NSLog(@"所有任务执行完成");
});
    
dispatch_async(queue, ^{
    [NSThread sleepForTimeInterval:4];
    NSLog(@"[任务5] %@", [NSThread currentThread]);
});

//当任务的队列为DISPATCH_QUEUE_SERIAL时,执行结果:
2021-04-16 16:27:21.101260+0800 Demo[87930:20756012] [任务1] {number = 7, name = (null)}
2021-04-16 16:27:23.106189+0800 Demo[87930:20756012] [任务2] {number = 7, name = (null)}
2021-04-16 16:27:25.111495+0800 Demo[87930:20756012] [任务3] {number = 7, name = (null)}
2021-04-16 16:27:25.111771+0800 Demo[87930:20756012] wait start
2021-04-16 16:27:31.112103+0800 Demo[87930:20756012] wait end
2021-04-16 16:27:35.116521+0800 Demo[87930:20756012] [任务4] {number = 7, name = (null)}
2021-04-16 16:27:39.119116+0800 Demo[87930:20756012] [任务5] {number = 7, name = (null)}
2021-04-16 16:27:39.119395+0800 Demo[87930:20756012] 所有任务执行完成

//当任务的队列为DISPATCH_QUEUE_CONCURRENT时,执行结果:
2021-04-16 16:48:48.220717+0800 Demo[88208:20774077] wait start
2021-04-16 16:48:50.223659+0800 Demo[88208:20774082] [任务1] {number = 3, name = (null)}
2021-04-16 16:48:50.223659+0800 Demo[88208:20774080] [任务2] {number = 6, name = (null)}
2021-04-16 16:48:50.223659+0800 Demo[88208:20774083] [任务3] {number = 7, name = (null)}
2021-04-16 16:48:50.223970+0800 Demo[88208:20774077] wait end
2021-04-16 16:48:50.223979+0800 Demo[88208:20774082] 所有任务执行完成
2021-04-16 16:48:52.222427+0800 Demo[88208:20774078] [任务5] {number = 9, name = (null)}
2021-04-16 16:48:52.222427+0800 Demo[88208:20774079] [任务4] {number = 4, name = (null)}

总结:

  1. dispatch_group_async函数是自动将任务添加到任务组中。
  2. dispatch_group_enter函数是手动将任务添加到任务组中。
  3. 当通过dispatch_group_enter函数被调用后,dispatch_group_leave函数调用前,其间的所有任务都被添加到任务组中。
  4. 当任务所在的队列为串行队列时,会等待group关联队列中所有任务执行完成之后才会发出notify信号,调用dispatch_group_notify函数,但是,当group组中的任务执行完成之后,会执行dispatch_group_wait函数。

dispatch_barrier_sync & dispatch_barrier_async

栅栏函数,主要有两种使用场景:串行队列、并发队列

  • 栅栏函数 + 串行队列
dispatch_queue_t queue = dispatch_queue_create("hqThread", DISPATCH_QUEUE_SERIAL);
dispatch_async(queue, ^{
    [NSThread sleepForTimeInterval:2];
    NSLog(@"[任务1] %@", [NSThread currentThread]);
});
    
dispatch_async(queue, ^{
    [NSThread sleepForTimeInterval:2];
    NSLog(@"[任务2] %@", [NSThread currentThread]);
});
    
dispatch_async(queue, ^{
    [NSThread sleepForTimeInterval:2];
    NSLog(@"[任务3] %@", [NSThread currentThread]);
});
    
dispatch_barrier_async(queue, ^{
    NSLog(@"------------栅栏任务------------%@", [NSThread currentThread]);
});
    
dispatch_async(queue, ^{
    NSLog(@"[任务4] %@", [NSThread currentThread]);
});
    
dispatch_async(queue, ^{
    NSLog(@"[任务5] %@", [NSThread currentThread]);
});

//执行结果
2021-04-19 09:46:18.453361+0800 Demo[13733:22451112] [任务1] {number = 6, name = (null)}
2021-04-19 09:46:20.458536+0800 Demo[13733:22451112] [任务2] {number = 6, name = (null)}
2021-04-19 09:46:22.463882+0800 Demo[13733:22451112] [任务3] {number = 6, name = (null)}
2021-04-19 09:46:22.464409+0800 Demo[13733:22451112] ------------栅栏任务------------{number = 6, name = (null)}
2021-04-19 09:46:22.464688+0800 Demo[13733:22451112] [任务4] {number = 6, name = (null)}
2021-04-19 09:46:22.464940+0800 Demo[13733:22451112] [任务5] {number = 6, name = (null)}
  • 栅栏函数 + 并发队列
dispatch_queue_t queue = dispatch_queue_create("hqThread", DISPATCH_QUEUE_CONCURRENT);//DISPATCH_QUEUE_CONCURRENT
dispatch_async(queue, ^{
    [NSThread sleepForTimeInterval:2];
    NSLog(@"[任务1] %@", [NSThread currentThread]);
});
    
dispatch_async(queue, ^{
    [NSThread sleepForTimeInterval:2];
    NSLog(@"[任务2] %@", [NSThread currentThread]);
});
    
dispatch_async(queue, ^{
    [NSThread sleepForTimeInterval:2];
    NSLog(@"[任务3] %@", [NSThread currentThread]);
});
    
dispatch_barrier_async(queue, ^{
    NSLog(@"------------栅栏任务------------%@", [NSThread currentThread]);
});
    
dispatch_async(queue, ^{
    NSLog(@"[任务4] %@", [NSThread currentThread]);
});
    
dispatch_async(queue, ^{
    NSLog(@"[任务5] %@", [NSThread currentThread]);
});

//执行结果
2021-04-19 09:47:09.266069+0800 Demo[13753:22452474] [任务2] {number = 5, name = (null)}
2021-04-19 09:47:09.266121+0800 Demo[13753:22452477] [任务1] {number = 8, name = (null)}
2021-04-19 09:47:09.266191+0800 Demo[13753:22452478] [任务3] {number = 3, name = (null)}
2021-04-19 09:47:09.266493+0800 Demo[13753:22452478] ------------栅栏任务------------{number = 3, name = (null)}
2021-04-19 09:47:09.266699+0800 Demo[13753:22452478] [任务4] {number = 3, name = (null)}
2021-04-19 09:47:09.266762+0800 Demo[13753:22452474] [任务5] {number = 5, name = (null)}

从上面代码和结果分析可知,dispatch_barrier_async函数的主要作用是等待队列中,位于dispatch_barrier_async函数前的任务完成之后,再执行dispatch_barrier_async函数后的任务。

在串行队列中,任务本身就是按顺序执行,因此,栅栏函数的作用不明显。而在并发队列中,使用栅栏函数可以很好的控制队列内任务执行的顺序。

重点:dispatch_barrier_asyncdispatch_barrier_sync
相同点:都是起到栅栏的作用,必须等待栅栏前面的任务执行完成之后再执行栅栏之后的任务。
不同点:dispatch_barrier_sync函数不仅会阻塞队列任务的执行,也会阻塞线程的执行,阻塞线程执行同dispatch_sync函数类似,也可能会引起死锁。所以dispatch_barrier_sync函数需要慎用。

栅栏函数中尽量使用自定义队列,因为使用全局队列是无效的,因为使用全局队列时由于对全局队列造成堵塞,可能致使系统其他调用全局队列的地方也堵塞从而导致崩溃。

dispatch_semaphore_t 信号量

信号量主要用作同步锁,用于控制GCD最大并发数。常见的函数有:

dispatch_semaphore_create():创建信号量dispatch_semaphore_t

dispatch_semaphore_wait():信号量减1.当信号量< 0时会阻塞当前线程,根据传入的等待时间决定接下来的操作——如果永久等待将等到信号(signal)才执行下去

dispatch_semaphore_signal():信号量加1.当信号量>= 0 会执行wait之后的代码.

示例代码如下:

dispatch_queue_t queue = dispatch_queue_create("hqThread", DISPATCH_QUEUE_CONCURRENT);
        
for (int i = 0; i < 10; i++) {
    dispatch_async(queue, ^{
        NSLog(@"当前 - %d, 线程 - %@", i, [NSThread currentThread]);
    });
}

//利用信号量来改写
dispatch_semaphore_t sem = dispatch_semaphore_create(0);
for (int i = 0; i < 10; i++) {
    dispatch_async(queue, ^{
        NSLog(@"当前 - %d, 线程 - %@", i, [NSThread currentThread]);

        dispatch_semaphore_signal(sem);
    });
    dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
}

如果当创建信号量时传入值为1又会怎么样呢?
答:当i=0时,开启线程去执行任务后,wait信号量-1,但是此时信号量为0不会阻塞线程,所以进入i=1;
当i=1时,开启线程去执行任务后,wait信号量-1,此时信号量为-1阻塞线程,它将等待signal(即信号量+1)后再执行下去;
因此,若是并发队列时,当创建信号量为1时,任务1和任务2执行顺序不固定。

dispatch_source_t

dispatch_source_t主要用于计时操作,其原因是因为它创建的timer不依赖于RunLoop,且计时精准度比NSTimer高。

在iOS开发中一般使用NSTimer来处理定时逻辑,但NSTimer是依赖Runloop的,而Runloop可以运行在不同的模式下。如果NSTimer添加在一种模式下,当Runloop运行在其他模式下的时候,定时器就挂机了;假如当前Runloop处于阻塞状态,NSTimer触发时间就会推迟到下一个Runloop周期。因此NSTimer在计时上会有误差,并不是特别精确,而GCD定时器不依赖Runloop,计时精度要高很多。

dispatch_source是一种基本的数据类型,可以用来监听一些底层的系统事件,如:

  • Timer Dispatch Source:定时器事件源,用来生成周期性的通知或回调

  • Signal Dispatch Source:监听信号事件源,当有UNIX信号发生时会通知

  • Descriptor Dispatch Source:监听文件或socket事件源,当文件或socket数据发生变化时会通知

  • Process Dispatch Source:监听进程事件源,与进程相关的事件通知

  • Mach port Dispatch Source:监听Mach端口事件源

  • Custom Dispatch Source:监听自定义事件源

Dispatch Source一共可以监听六类事件,分为11个类型:

  • DISPATCH_SOURCE_TYPE_DATA_ADD:属于自定义事件,可以通过dispatch_source_get_data函数获取事件变量数据,在我们自定义的方法中可以调用dispatch_source_merge_data函数向Dispatch Source设置数据,下文中会有详细的演示。

  • DISPATCH_SOURCE_TYPE_DATA_OR:属于自定义事件,用法同上面的类型一样。

  • DISPATCH_SOURCE_TYPE_MACH_SEND:Mach端口发送事件。

  • DISPATCH_SOURCE_TYPE_MACH_RECV:Mach端口接收事件。

  • DISPATCH_SOURCE_TYPE_PROC:与进程相关的事件。

  • DISPATCH_SOURCE_TYPE_READ:读文件事件。

  • DISPATCH_SOURCE_TYPE_WRITE:写文件事件。

  • DISPATCH_SOURCE_TYPE_VNODE:文件属性更改事件。

  • DISPATCH_SOURCE_TYPE_SIGNAL:接收信号事件。

  • DISPATCH_SOURCE_TYPE_TIMER:定时器事件。

  • DISPATCH_SOURCE_TYPE_MEMORYPRESSURE:内存压力事件

主要使用的API:

  • dispatch_source_create: 创建事件源
/*
* 参数1(type):第一个参数用于标识Dispatch Source要监听的事件类型,共有11个类型
* 参数2(handle):取决于要监听事件的类型,比如监听的是Mach端口相关的事件,那该参数就是mach_port_t类型的Mach端口号;
* 参数3(mask):取决于要监听事件的类型,比如监听文件属性更改的事件,那么该参数就是标识文件的哪个属性,如:DISPATCH_VNODE_RENAME
* 参数4(queue):回调函数所在的队列
*/
dispatch_source_t dispatch_source_create(dispatch_source_type_t type, uintptr_t handle, uintptr_t mask, dispatch_queue_t _Nullable queue);
    
//示例
dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
  • dispatch_source_set_timer:给监听事件类型为DISPATCH_SOURCE_TYPE_TIMER的Dispatch Source设置相关属性
/*
* 参数1(source):该参数为目标Dispatch Source
* 参数2(start):定时器的起始时间
* 参数3(interval):定时器的间隔时间,单位为纳秒
* 参数4(leeway):间隔时间的精度,单位为纳秒
*/
void dispatch_source_set_timer(dispatch_source_t source, dispatch_time_t start, uint64_t interval, uint64_t leeway);

//示例
dispatch_source_set_timer(timer, DISPATCH_TIME_NOW, 1.0*NSEC_PER_SEC, 0.1*NSEC_PER_SEC);
  • dispatch_source_set_event_handler: 设置数据源回调。
    当Dispatch Source监听到事件时,会调用指定的回调函数或者闭包,该回调函数和闭包就是Dispatch Source的事件处理器,我们可以通过dispatch_source_set_event_handler或者dispatch_source_set_event_handler_f给创建好的Dispatch Source设置处理器,其中前者是设置闭包形式的处理器,后者是设置函数形式的处理器。
/*
* 参数1(source):目标Dispatch Source
* 参数2(handler):事件处理器
*/
void dispatch_source_set_event_handler(dispatch_source_t source, dispatch_block_t _Nullable handler);

//示例
dispatch_source_set_event_handler(self.timer, ^{
    NSLog(@"GCDTimer");
});
  • dispatch_source_merge_data: 设置事件源数据。
    将数据合并到Dispatch Source中,并将handler提交到目标队列queue再执行。
/*
* 参数1(source):目标Dispatch Source
* 参数2(value):需要合并的数据
*/
void
dispatch_source_merge_data(dispatch_source_t source, uintptr_t value);

//示例
dispatch_source_merge_data(source, 100)
  • dispatch_source_get_data: 获取事件源数据
/*
* 参数1(source):目标Dispatch Source
* 返回值:Dispatch Source待处理的数据
*/
uintptr_t dispatch_source_get_data(dispatch_source_t source);

//示例
dispatch_source_get_data(source)
  • dispatch_resume: 继续
    刚创建好的Dispatch Source是处于暂停状态的,需要手动调用dispatch_resume函数将其启动。
/*
* 参数1(object):非活动的、未挂起的调度源对象
*/
void dispatch_resume(dispatch_object_t object);

//示例
dispatch_resume(timer)
  • dispatch_suspend: 挂起,将Dispatch Source暂时挂起,挂起后可通过dispatch_resume重新激活。
/*
* 参数1(object):调度源对象
*/
void dispatch_suspend(dispatch_object_t object);

//示例
dispatch_suspend(timer)

NSOperation

NSOperation基于GCD的更高一层的封装,NSOperation需要配合NSOperationQueue来实现多线程。
NSOperation实现多线程步骤如下:

  1. 创建任务,将需要执行的任务封装到NSOperation对象中
  2. 创建队列,创建NSOperationQueue队列
  3. 将任务添加到队列中。将NSOperation对象添加到NSOperationQueue中。

基本使用:

NSBlockOperation* operation = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"NSBlockOperation");
}];
NSOperationQueue* queue = [[NSOperationQueue alloc] init];
[queue addOperation:operation];

NSOperation类是一个抽象类,实际使用中使用的是NSOperation的子类。

  • NSInvocationOperation类
NSOperationQueue* queue = [[NSOperationQueue alloc] init];
NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(doSomething:) object:@"NSInvocationOperation"];
[queue addOperation:invocationOperation];
  • NSBlockOperation类
NSOperationQueue* queue = [[NSOperationQueue alloc] init];
NSBlockOperation* operation = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"NSBlockOperation1 - %@", [NSThread currentThread]);
}];
    
[operation addExecutionBlock:^{
    NSLog(@"NSBlockOperation2 - %@", [NSThread currentThread]);
}];
    
[operation addExecutionBlock:^{
    NSLog(@"NSBlockOperation3 - %@", [NSThread currentThread]);
}];
    
[queue addOperation:operation];
  • 自定义NSOperation类
    自定义NSOperation类可以通过实现内部相应的方法来封装任务。
@interface HQOperation : NSOperation
@end

@implementation HQOperation
- (void)main{
    for(int i = 0; i < 3; i++){
        NSLog(@"[%d] %@", i, [NSThread currentThread]);
    }
}
@end

HQOperation* operation = [[HQOperation alloc] init];
[operation start];

NSOperation设置优先级

NSOperationQueue* queue = [[NSOperationQueue alloc] init];
NSBlockOperation* operation1 = [NSBlockOperation blockOperationWithBlock:^{
    [NSThread sleepForTimeInterval:3];
    NSLog(@"NSBlockOperation1 - %@", [NSThread currentThread]);
}];
    
NSBlockOperation* operation2 = [NSBlockOperation blockOperationWithBlock:^{
    [NSThread sleepForTimeInterval:3];
    NSLog(@"NSBlockOperation2 - %@", [NSThread currentThread]);
}];

//设置了最高优先级
operation2.qualityOfService = NSQualityOfServiceUserInteractive;
    
[queue addOperation:operation1];
[queue addOperation:operation2];

//执行结果
2021-04-20 15:21:42.698211+0800 Demo[24004:23167490] NSBlockOperation2 - {number = 7, name = (null)}
2021-04-20 15:21:42.701567+0800 Demo[24004:23167487] NSBlockOperation1 - {number = 8, name = (null)}

设置并发数,在GCD的使用中,可以通过信号量的方式来设置并发数,同样,在NSOperation中,也可以轻松设置并发数。

NSOperationQueue* queue = [[NSOperationQueue alloc] init];
//设置最大并发数为3,即同时有3条线程执行任务
queue.maxConcurrentOperationCount = 3;
for(int i = 0; i<10; i++){
    [queue addOperationWithBlock:^{
        NSLog(@"[%d] -- %@", i, [NSThread currentThread]);
    }];
}

//执行结果
2021-04-20 15:29:07.062726+0800 Demo[24082:23173786] [0] -- {number = 3, name = (null)}
2021-04-20 15:29:07.062730+0800 Demo[24082:23173778] [1] -- {number = 7, name = (null)}
2021-04-20 15:29:07.062780+0800 Demo[24082:23173787] [2] -- {number = 6, name = (null)}
2021-04-20 15:29:07.062934+0800 Demo[24082:23173786] [3] -- {number = 3, name = (null)}
2021-04-20 15:29:07.062988+0800 Demo[24082:23173787] [5] -- {number = 6, name = (null)}
2021-04-20 15:29:07.062994+0800 Demo[24082:23173778] [4] -- {number = 7, name = (null)}
2021-04-20 15:29:07.063117+0800 Demo[24082:23173786] [6] -- {number = 3, name = (null)}
2021-04-20 15:29:07.063154+0800 Demo[24082:23173787] [7] -- {number = 6, name = (null)}
2021-04-20 15:29:07.063269+0800 Demo[24082:23173778] [8] -- {number = 7, name = (null)}
2021-04-20 15:29:07.064370+0800 Demo[24082:23173786] [9] -- {number = 3, name = (null)}

在NSOperation中,还可以添加依赖关系

NSOperationQueue* queue = [[NSOperationQueue alloc] init];
NSBlockOperation* operation1 = [NSBlockOperation blockOperationWithBlock:^{
    [NSThread sleepForTimeInterval:3];
    NSLog(@"请求数据1 - %@", [NSThread currentThread]);
}];
    
NSBlockOperation* operation2 = [NSBlockOperation blockOperationWithBlock:^{
    [NSThread sleepForTimeInterval:3];
    NSLog(@"根据数据1,请求数据2 - %@", [NSThread currentThread]);
}];
    
NSBlockOperation* operation3 = [NSBlockOperation blockOperationWithBlock:^{
    [NSThread sleepForTimeInterval:3];
    NSLog(@"根据数据2,请求数据3 - %@", [NSThread currentThread]);
}];
    
[operation2 addDependency:operation1];
[operation3 addDependency:operation2];
[queue addOperation:operation1];
[queue addOperation:operation2];
[queue addOperation:operation3];

//执行结果
2021-04-20 15:33:51.102025+0800 Demo[24165:23179016] 请求数据1 - {number = 7, name = (null)}
2021-04-20 15:33:54.104030+0800 Demo[24165:23179022] 根据数据1,请求数据2 - {number = 6, name = (null)}
2021-04-20 15:33:57.108527+0800 Demo[24165:23179016] 根据数据2,请求数据3 - {number = 7, name = (null)}

你可能感兴趣的:(OC底层原理 - 21 NSThread&GCD& NSOperation)