前言
在使用ReactiveCocoa 過程中，Josh Abernathy和Justin Spahr-Summers 兩位大神為了能讓RAC的使用者更暢快的在沉浸在FRP的世界裡，更好的進行併發程式設計，於是就對GCD進行了一次封裝，並與RAC的各大元件進行了完美的整合。
自從有了RACScheduler以後，使整個RAC併發程式設計的程式碼裡面更加和諧統一，更加順手，更加“ReactiveCocoa”。
目錄
- 1.RACScheduler是如何封裝GCD的
- 2.RACSequence的一些子類
- 3.RACScheduler是如何“取消”併發任務的
- 4.RACScheduler是如何和RAC其他元件進行完美整合的
一. RACScheduler是如何封裝GCD的
RACScheduler在ReactiveCocoa中到底是幹嘛的呢？處於什麼地位呢？官方給出的定義如下：
Schedulers are used to control when and where work is performed複製程式碼RACScheduler在ReactiveCocoa中是用來控制一個任務，何時何地被執行。它主要是用來解決ReactiveCocoa中併發程式設計的問題的。
RACScheduler的實質是對GCD的封裝，底層就是GCD實現的。
要分析RACScheduler，先來回顧一下GCD。
眾所周知，在GCD中，Dispatch Queue主要分為2類，Serial Dispatch Queue 和 Concurrent Dispatch Queue 。其中Serial Dispatch Queue是等待現在執行中處理結束的佇列，Concurrent Dispatch Queue是不等待現在執行中處理結束的佇列。
生成Dispatch Queue的方法也有2種，第一種方式是通過GCD的API生成Dispatch Queue。
生成Serial Dispatch Queue
dispatch_queue_t serialDispatchQueue = dispatch_queue_create("com.gcd.SerialDispatchQueue", DISPATCH_QUEUE_SERIAL);複製程式碼生成Concurrent Dispatch Queue
dispatch_queue_t concurrentDispatchQueue = dispatch_queue_create("com.gcd.ConcurrentDispatchQueue", DISPATCH_QUEUE_CONCURRENT);複製程式碼第二種方法是直接獲取系統提供的Dispatch Queue。系統提供的也分為2類，Main Dispatch Queue 和 Global Dispatch Queue。Main Dispatch Queue 對應著是Serial Dispatch Queue，Global Dispatch Queue 對應著是Concurrent Dispatch Queue。
Global Dispatch Queue主要分為8種。
首先是以下4種，分別是優先順序對應Qos的情況。
- DISPATCH_QUEUE_PRIORITY_HIGH: QOS_CLASS_USER_INITIATED
- DISPATCH_QUEUE_PRIORITY_DEFAULT: QOS_CLASS_DEFAULT
- DISPATCH_QUEUE_PRIORITY_LOW: QOS_CLASS_UTILITY
- DISPATCH_QUEUE_PRIORITY_BACKGROUND: QOS_CLASS_BACKGROUND複製程式碼其次是，是否支援 overcommit。加上上面4個優先順序，所以一共8種Global Dispatch Queue。帶有 overcommit 的佇列表示每當有任務提交時，系統都會新開一個執行緒處理，這樣就不會造成某個執行緒過載(overcommit)。
回到RACScheduler中來，RACScheduler既然是對GCD的封裝，那麼上述說的這些型別也都有其一一對應的封裝。
typedef enum : long {
RACSchedulerPriorityHigh = DISPATCH_QUEUE_PRIORITY_HIGH,
RACSchedulerPriorityDefault = DISPATCH_QUEUE_PRIORITY_DEFAULT,
RACSchedulerPriorityLow = DISPATCH_QUEUE_PRIORITY_LOW,
RACSchedulerPriorityBackground = DISPATCH_QUEUE_PRIORITY_BACKGROUND,
} RACSchedulerPriority;複製程式碼首先是RACScheduler中的優先順序，這裡只封裝了4種，也是分別對應GCD中的DISPATCH_QUEUE_PRIORITY_HIGH，DISPATCH_QUEUE_PRIORITY_DEFAULT，DISPATCH_QUEUE_PRIORITY_LOW，DISPATCH_QUEUE_PRIORITY_BACKGROUND。
RACScheduler有6個類方法，都是用來生成一個queue的。
+ (RACScheduler *)immediateScheduler;
+ (RACScheduler *)mainThreadScheduler;
+ (RACScheduler *)schedulerWithPriority:(RACSchedulerPriority)priority name:(NSString *)name;
+ (RACScheduler *)schedulerWithPriority:(RACSchedulerPriority)priority;
+ (RACScheduler *)scheduler;
+ (RACScheduler *)currentScheduler;複製程式碼接下來依次分析一下它們的底層實現。
1. immediateScheduler
+ (instancetype)immediateScheduler {
static dispatch_once_t onceToken;
static RACScheduler *immediateScheduler;
dispatch_once(&onceToken, ^{
immediateScheduler = [[RACImmediateScheduler alloc] init];
});
return immediateScheduler;
}複製程式碼immediateScheduler底層實現就是生成了一個RACImmediateScheduler的單例。
RACImmediateScheduler 是繼承自RACScheduler。
@interface RACImmediateScheduler : RACScheduler
@end複製程式碼在RACScheduler中，每個種類的RACScheduler都會有一個name屬性，名字也算是他們的標示。RACImmediateScheduler的name是@”com.ReactiveCocoa.RACScheduler.immediateScheduler”
RACImmediateScheduler的作用和它的名字一樣，是立即執行閉包裡面的任務。
- (RACDisposable *)schedule:(void (^)(void))block {
NSCParameterAssert(block != NULL);
block();
return nil;
}
- (RACDisposable *)after:(NSDate *)date schedule:(void (^)(void))block {
NSCParameterAssert(date != nil);
NSCParameterAssert(block != NULL);
[NSThread sleepUntilDate:date];
block();
return nil;
}複製程式碼在schedule:方法中，直接呼叫執行入參block( )閉包。在after: schedule:方法中，執行緒先睡眠，直到date的時刻，再醒過來執行入參block( )閉包。
- (RACDisposable *)after:(NSDate *)date repeatingEvery:(NSTimeInterval)interval withLeeway:(NSTimeInterval)leeway schedule:(void (^)(void))block {
NSCAssert(NO, @"+[RACScheduler immediateScheduler] does not support %@.", NSStringFromSelector(_cmd));
return nil;
}複製程式碼當然RACImmediateScheduler是不可能支援after: repeatingEvery: withLeeway: schedule:方法的。因為它的定義就是立即執行的，不應該repeat。
- (RACDisposable *)scheduleRecursiveBlock:(RACSchedulerRecursiveBlock)recursiveBlock {
for (__block NSUInteger remaining = 1; remaining > 0; remaining--) {
recursiveBlock(^{
remaining++;
});
}
return nil;
}複製程式碼RACImmediateScheduler的scheduleRecursiveBlock:方法中只要recursiveBlock閉包存在，就會無限遞迴呼叫執行，除非recursiveBlock不存在了。
2. mainThreadScheduler
mainThreadScheduler也是一個型別是RACTargetQueueScheduler的單例。
+ (instancetype)mainThreadScheduler {
static dispatch_once_t onceToken;
static RACScheduler *mainThreadScheduler;
dispatch_once(&onceToken, ^{
mainThreadScheduler = [[RACTargetQueueScheduler alloc] initWithName:@"com.ReactiveCocoa.RACScheduler.mainThreadScheduler" targetQueue:dispatch_get_main_queue()];
});
return mainThreadScheduler;
}複製程式碼mainThreadScheduler的名字是@”com.ReactiveCocoa.RACScheduler.mainThreadScheduler”。
RACTargetQueueScheduler繼承自RACQueueScheduler
@interface RACTargetQueueScheduler : RACQueueScheduler
- (id)initWithName:(NSString *)name targetQueue:(dispatch_queue_t)targetQueue;
@end複製程式碼在RACTargetQueueScheduler中，只有一個初始化方法。
- (id)initWithName:(NSString *)name targetQueue:(dispatch_queue_t)targetQueue {
NSCParameterAssert(targetQueue != NULL);
if (name == nil) {
name = [NSString stringWithFormat:@"com.ReactiveCocoa.RACTargetQueueScheduler(%s)", dispatch_queue_get_label(targetQueue)];
}
dispatch_queue_t queue = dispatch_queue_create(name.UTF8String, DISPATCH_QUEUE_SERIAL);
if (queue == NULL) return nil;
dispatch_set_target_queue(queue, targetQueue);
return [super initWithName:name queue:queue];
}複製程式碼先新建了一個queue，name是@”com.ReactiveCocoa.RACScheduler.mainThreadScheduler”，型別是Serial Dispatch Queue 型別的，然後呼叫了dispatch_set_target_queue方法。
所以重點就在dispatch_set_target_queue方法裡面了。
dispatch_set_target_queue方法主要有兩個目的：一是設定dispatch_queue_create建立佇列的優先順序，二是建立佇列的執行階層。
- 當使用dispatch_queue_create建立佇列的時候，不管是序列還是並行，它們的優先順序都是DISPATCH_QUEUE_PRIORITY_DEFAULT級別，而這個API就是可以設定佇列的優先順序。
舉個例子：
dispatch_queue_t serialQueue = dispatch_queue_create("serialQueue", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
//注意：被設定優先順序的佇列是第一個引數。
dispatch_set_target_queue(serialQueue, globalQueue);複製程式碼通過上面的程式碼，就把將serailQueue設定成DISPATCH_QUEUE_PRIORITY_HIGH。
- 使用這個dispatch_set_target_queue方法可以設定佇列執行階層，例如dispatch_set_target_queue(queue, targetQueue);
這樣設定時，相當於將queue指派給targetQueue，如果targetQueue是序列佇列，則queue是序列執行的；如果targetQueue是並行佇列，那麼queue是並行的。
舉個例子：
dispatch_queue_t targetQueue = dispatch_queue_create("targetQueue", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t queue1 = dispatch_queue_create("queue1", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t queue2 = dispatch_queue_create("queue2", DISPATCH_QUEUE_CONCURRENT);
dispatch_set_target_queue(queue1, targetQueue);
dispatch_set_target_queue(queue2, targetQueue);
dispatch_async(queue1, ^{
NSLog(@"queue1 1");
});
dispatch_async(queue1, ^{
NSLog(@"queue1 2");
});
dispatch_async(queue2, ^{
NSLog(@"queue2 1");
});
dispatch_async(queue2, ^{
NSLog(@"queue2 2");
});
dispatch_async(targetQueue, ^{
NSLog(@"target queue");
});複製程式碼如果targetQueue為Serial Dispatch Queue，那麼輸出結果必定如下：
queue1 1
queue1 2
queue2 1
queue2 2
target queue複製程式碼如果targetQueue為Concurrent Dispatch Queue，那麼輸出結果可能如下：
queue1 1
queue2 1
queue1 2
target queue
queue2 2複製程式碼回到RACTargetQueueScheduler中來，在這裡傳進來的入參是dispatch_get_main_queue( )，這是一個Serial Dispatch Queue，這裡再呼叫dispatch_set_target_queue方法，相當於把queue的優先順序設定的和main_queue一致。
3. scheduler
以下三個方法實質是同一個方法。
+ (RACScheduler *)schedulerWithPriority:(RACSchedulerPriority)priority name:(NSString *)name;
+ (RACScheduler *)schedulerWithPriority:(RACSchedulerPriority)priority;
+ (RACScheduler *)scheduler;複製程式碼
+ (instancetype)schedulerWithPriority:(RACSchedulerPriority)priority name:(NSString *)name {
return [[RACTargetQueueScheduler alloc] initWithName:name targetQueue:dispatch_get_global_queue(priority, 0)];
}
+ (instancetype)schedulerWithPriority:(RACSchedulerPriority)priority {
return [self schedulerWithPriority:priority name:@"com.ReactiveCocoa.RACScheduler.backgroundScheduler"];
}
+ (instancetype)scheduler {
return [self schedulerWithPriority:RACSchedulerPriorityDefault];
}複製程式碼通過原始碼我們能知道，scheduler這一系列的三個方法，是建立了一個 Global Dispatch Queue，對應的屬於Concurrent Dispatch Queue。
schedulerWithPriority: name:方法可以指定執行緒的優先順序和名字。
schedulerWithPriority:方法只能執行優先順序，名字為預設的@”com.ReactiveCocoa.RACScheduler.backgroundScheduler”。
scheduler方法建立出來的queue的優先順序是預設的，名字也是預設的@”com.ReactiveCocoa.RACScheduler.backgroundScheduler”。
注意，scheduler和mainThreadScheduler，immediateScheduler這兩個單例不同的是，scheduler每次都會建立一個新的Concurrent Dispatch Queue。
4. currentScheduler
+ (instancetype)currentScheduler {
RACScheduler *scheduler = NSThread.currentThread.threadDictionary[RACSchedulerCurrentSchedulerKey];
if (scheduler != nil) return scheduler;
if ([self.class isOnMainThread]) return RACScheduler.mainThreadScheduler;
return nil;
}複製程式碼首先，在ReactiveCocoa 中定義了這麼一個key，@”RACSchedulerCurrentSchedulerKey”，這個用來從執行緒字典裡面存取出對應的RACScheduler。
NSString * const RACSchedulerCurrentSchedulerKey = @"RACSchedulerCurrentSchedulerKey";複製程式碼在currentScheduler這個方法裡面看到的是從執行緒字典裡面取出一個RACScheduler。至於什麼時候存的，下面會解釋到。
如果能從執行緒字典裡面取出一個RACScheduler，就返回取出的RACScheduler。如果字典裡面沒有，再判斷當前的scheduler是否是在主執行緒上。
+ (BOOL)isOnMainThread {
return [NSOperationQueue.currentQueue isEqual:NSOperationQueue.mainQueue] || [NSThread isMainThread];
}複製程式碼判斷方法如上，只要是NSOperationQueue在mainQueue上，或者NSThread是主執行緒，都算是在主執行緒上。
如果是在主執行緒上，就返回mainThreadScheduler。
如果既不在主執行緒上，執行緒字典裡面也找不到對應key值對應的value，那麼就返回nil。
RACScheduler除了有6個類方法，還有4個例項方法：
- (RACDisposable *)schedule:(void (^)(void))block;
- (RACDisposable *)after:(NSDate *)date schedule:(void (^)(void))block;
- (RACDisposable *)afterDelay:(NSTimeInterval)delay schedule:(void (^)(void))block;
- (RACDisposable *)after:(NSDate *)date repeatingEvery:(NSTimeInterval)interval withLeeway:(NSTimeInterval)leeway schedule:(void (^)(void))block;複製程式碼這4個方法其實從名字上就知道是用來幹嘛的。
schedule:是為RACScheduler新增一個任務，入參是一個閉包。
after: schedule:是為RACScheduler新增一個定時任務，在date時間之後才執行任務。
afterDelay: schedule:是為RACScheduler新增一個延時執行的任務，延時delay時間之後才執行任務。
after: repeatingEvery: withLeeway: schedule:是為RACScheduler新增一個定時任務，在date時間之後才開始執行，然後每隔interval秒執行一次任務。
這四個方法會分別在RACScheduler的各個子類裡面進行重寫。
比如之前提到的immediateScheduler，schedule:方法中會直接立即執行閉包。after: schedule:方法中新增一個定時任務，在date時間之後才執行任務。after: repeatingEvery: withLeeway: schedule:這個方法在RACImmediateScheduler中就直接返回nil。
還有其他子類在下面會分析這4個方法的實現。
另外還有最後3個方法
- (RACDisposable *)scheduleRecursiveBlock:(RACSchedulerRecursiveBlock)recursiveBlock;
- (void)scheduleRecursiveBlock:(RACSchedulerRecursiveBlock)recursiveBlock addingToDisposable:(RACCompoundDisposable *)disposable
- (void)performAsCurrentScheduler:(void (^)(void))block;複製程式碼前兩個方法是實現RACSequence中signalWithScheduler:方法的，具體分析見這篇文章
performAsCurrentScheduler:方法是在RACQueueScheduler中使用到了，在下面子類分析裡面詳細分析。
二. RACSequence的一些子類
RACSequence總共有以下5個子類。
1. RACTestScheduler
這個類主要是一個測試類，主要用在單元測試中，它是用來驗證非同步呼叫沒有花費大量的時間等待。RACTestScheduler也可以用在多執行緒當中，當時一次只能在排隊的方法佇列中選擇一個方法執行。
@interface RACTestSchedulerAction : NSObject
@property (nonatomic, copy, readonly) NSDate *date;
@property (nonatomic, copy, readonly) void (^block)(void);
@property (nonatomic, strong, readonly) RACDisposable *disposable;
- (id)initWithDate:(NSDate *)date block:(void (^)(void))block;
@end複製程式碼在單元測試中，ReactiveCocoa為了方便比較每個方法的呼叫，新建了一個RACTestSchedulerAction物件，用來更加方便的比較和描述測試的全過程。RACTestSchedulerAction的定義如上。現在再來解釋一下引數。
date是一個時間，時間主要是用來比較和決定下一次該輪到哪個閉包要開始執行了。
void (^block)(void)閉包是RACScheduler中的一個任務。
disposable是控制一個action是否可以執行的。一旦disposed了，那麼這個action就不會被執行。
initWithDate: block: 方法是初始化一個新的action。
在單元測試過程中，需要呼叫step方法來進行檢視每次呼叫閉包的情況。
- (void)step {
[self step:1];
}
- (void)stepAll {
[self step:NSUIntegerMax];
}複製程式碼step和stepAll方法都是呼叫step:方法。step只是執行一次RACScheduler中的任務，stepAll是執行所有的RACScheduler中的任務。既然都是呼叫step:，那接下來分析一下step:的具體實現。
- (void)step:(NSUInteger)ticks {
@synchronized (self) {
for (NSUInteger i = 0; i < ticks; i++) {
const void *actionPtr = NULL;
if (!CFBinaryHeapGetMinimumIfPresent(self.scheduledActions, &actionPtr)) break;
RACTestSchedulerAction *action = (__bridge id)actionPtr;
CFBinaryHeapRemoveMinimumValue(self.scheduledActions);
if (action.disposable.disposed) continue;
RACScheduler *previousScheduler = RACScheduler.currentScheduler;
NSThread.currentThread.threadDictionary[RACSchedulerCurrentSchedulerKey] = self;
action.block();
if (previousScheduler != nil) {
NSThread.currentThread.threadDictionary[RACSchedulerCurrentSchedulerKey] = previousScheduler;
} else {
[NSThread.currentThread.threadDictionary removeObjectForKey:RACSchedulerCurrentSchedulerKey];
}
}
}
}複製程式碼step:的實現主要就是一個for迴圈。迴圈的次數就是入參ticks決定的。首先const void *actionPtr是一個指向函式的指標。在上述實現中有一個很重要的函式——CFBinaryHeapGetMinimumIfPresent。該函式的原型如下：
Boolean CFBinaryHeapGetMinimumIfPresent(CFBinaryHeapRef heap, const void **value)複製程式碼這個函式的主要作用的是在二分堆heap中查詢一個最小值。
static CFComparisonResult RACCompareScheduledActions(const void *ptr1, const void *ptr2, void *info) {
RACTestSchedulerAction *action1 = (__bridge id)ptr1;
RACTestSchedulerAction *action2 = (__bridge id)ptr2;
return CFDateCompare((__bridge CFDateRef)action1.date, (__bridge CFDateRef)action2.date, NULL);
}複製程式碼比較規則如上，就是比較兩者的date的值。從二分堆中找出這樣一個最小值，對應的就是scheduler中的任務。如果最小值有幾個相等最小值，就隨機返回一個最小值。返回的函式放在actionPtr中。整個函式的返回值是一個BOOL值，如果二分堆不為空，能找到最小值就返回YES，如果二分堆為空，就找不到最小值了，就返回NO。
stepAll方法裡面傳入了NSUIntegerMax，這個for迴圈也不會死迴圈，因為到堆中所有的任務都執行完成之後，CFBinaryHeapGetMinimumIfPresent返回NO，就會執行break，跳出迴圈。
這裡會把currentScheduler儲存到執行緒字典裡面。接著會執行action.block，執行任務。
- (RACDisposable *)schedule:(void (^)(void))block {
NSCParameterAssert(block != nil);
@synchronized (self) {
NSDate *uniqueDate = [NSDate dateWithTimeIntervalSinceReferenceDate:self.numberOfDirectlyScheduledBlocks];
self.numberOfDirectlyScheduledBlocks++;
RACTestSchedulerAction *action = [[RACTestSchedulerAction alloc] initWithDate:uniqueDate block:block];
CFBinaryHeapAddValue(self.scheduledActions, (__bridge void *)action);
return action.disposable;
}
}
- (RACDisposable *)after:(NSDate *)date schedule:(void (^)(void))block {
NSCParameterAssert(date != nil);
NSCParameterAssert(block != nil);
@synchronized (self) {
RACTestSchedulerAction *action = [[RACTestSchedulerAction alloc] initWithDate:date block:block];
CFBinaryHeapAddValue(self.scheduledActions, (__bridge void *)action);
return action.disposable;
}
}複製程式碼schedule:方法裡面會累加numberOfDirectlyScheduledBlocks值，這個值也會初始化成時間，以便比較各個方法該排程的時間。numberOfDirectlyScheduledBlocks最終會代表總共有多少個block任務產生了。然後用CFBinaryHeapAddValue加入到堆中。
after:schedule:就是直接新建RACTestSchedulerAction物件，然後再用CFBinaryHeapAddValue把block閉包加入到堆中。
after: repeatingEvery: withLeeway: schedule:同樣也是新建RACTestSchedulerAction物件，然後再用CFBinaryHeapAddValue把block閉包加入到堆中。
2. RACSubscriptionScheduler
RACSubscriptionScheduler是RACScheduler最後一個單例。RACScheduler中唯一的三個單例現在就齊全了：RACImmediateScheduler，RACTargetQueueScheduler ，RACSubscriptionScheduler。
+ (instancetype)subscriptionScheduler {
static dispatch_once_t onceToken;
static RACScheduler *subscriptionScheduler;
dispatch_once(&onceToken, ^{
subscriptionScheduler = [[RACSubscriptionScheduler alloc] init];
});
return subscriptionScheduler;
}複製程式碼RACSubscriptionScheduler 的名字是@”com.ReactiveCocoa.RACScheduler.subscriptionScheduler”
- (id)init {
self = [super initWithName:@"com.ReactiveCocoa.RACScheduler.subscriptionScheduler"];
if (self == nil) return nil;
_backgroundScheduler = [RACScheduler scheduler];
return self;
}複製程式碼RACSubscriptionScheduler初始化的時候會新建一個Global Dispatch Queue。
- (RACDisposable *)schedule:(void (^)(void))block {
NSCParameterAssert(block != NULL);
if (RACScheduler.currentScheduler == nil) return [self.backgroundScheduler schedule:block];
block();
return nil;
}複製程式碼如果RACScheduler.currentScheduler為nil就用backgroundScheduler去呼叫block閉包，否則就執行block閉包。
- (RACDisposable *)after:(NSDate *)date schedule:(void (^)(void))block {
RACScheduler *scheduler = RACScheduler.currentScheduler ?: self.backgroundScheduler;
return [scheduler after:date schedule:block];
}複製程式碼
- (RACDisposable *)after:(NSDate *)date repeatingEvery:(NSTimeInterval)interval withLeeway:(NSTimeInterval)leeway schedule:(void (^)(void))block {
RACScheduler *scheduler = RACScheduler.currentScheduler ?: self.backgroundScheduler;
return [scheduler after:date repeatingEvery:interval withLeeway:leeway schedule:block];
}複製程式碼兩個after方法都有取出RACScheduler.currentScheduler，如果為空就用self.backgroundScheduler去呼叫各自的after的方法。
RACSubscriptionScheduler中的backgroundScheduler的意義就在此，當RACScheduler.currentScheduler不存在的時候就會替換成self.backgroundScheduler。
3. RACImmediateScheduler
這個子類在分析immediateScheduler方法的時候，詳細分析過了，這裡不再贅述。
4. RACQueueScheduler
- (RACDisposable *)schedule:(void (^)(void))block {
NSCParameterAssert(block != NULL);
RACDisposable *disposable = [[RACDisposable alloc] init];
dispatch_async(self.queue, ^{
if (disposable.disposed) return;
[self performAsCurrentScheduler:block];
});
return disposable;
}複製程式碼schedule:會呼叫performAsCurrentScheduler:方法。
- (void)performAsCurrentScheduler:(void (^)(void))block {
NSCParameterAssert(block != NULL);
RACScheduler *previousScheduler = RACScheduler.currentScheduler;
NSThread.currentThread.threadDictionary[RACSchedulerCurrentSchedulerKey] = self;
@autoreleasepool {
block();
}
if (previousScheduler != nil) {
NSThread.currentThread.threadDictionary[RACSchedulerCurrentSchedulerKey] = previousScheduler;
} else {
[NSThread.currentThread.threadDictionary removeObjectForKey:RACSchedulerCurrentSchedulerKey];
}
}複製程式碼performAsCurrentScheduler:方法會先在呼叫block( )之前，把當前的scheduler存入執行緒字典中。
試想，如果現在在一個Concurrent Dispatch Queue中，在執行block( )之前需要先切換執行緒，切換到當前scheduler中。當執行完block閉包之後，previousScheduler如果不為nil，那麼就還原現場，執行緒字典裡面再存回原來的scheduler，反之previousScheduler為nil，那麼就移除掉執行緒字典裡面的key。
這裡需要值得注意的是：
scheduler本質其實是一個quene，並不是一個執行緒。它只能保證裡面的執行緒都是序列執行的，但是它不能保證每個執行緒不一定都是在同一個執行緒裡面執行。
如上面這段performAsCurrentScheduler:的實現所表現的那樣。所以
在scheduler使用Core Data很容易崩潰，很可能跑到子執行緒上面去了。一旦寫資料的時候到了子執行緒上，很容易就Crash了。一定要記得回到main queue上。
- (RACDisposable *)after:(NSDate *)date schedule:(void (^)(void))block {
NSCParameterAssert(date != nil);
NSCParameterAssert(block != NULL);
RACDisposable *disposable = [[RACDisposable alloc] init];
dispatch_after([self.class wallTimeWithDate:date], self.queue, ^{
if (disposable.disposed) return;
[self performAsCurrentScheduler:block];
});
return disposable;
}複製程式碼在after中呼叫dispatch_after方法，經過date時間之後再呼叫performAsCurrentScheduler:。
wallTimeWithDate:的實現如下：
+ (dispatch_time_t)wallTimeWithDate:(NSDate *)date {
NSCParameterAssert(date != nil);
double seconds = 0;
double frac = modf(date.timeIntervalSince1970, &seconds);
struct timespec walltime = {
.tv_sec = (time_t)fmin(fmax(seconds, LONG_MIN), LONG_MAX),
.tv_nsec = (long)fmin(fmax(frac * NSEC_PER_SEC, LONG_MIN), LONG_MAX)
};
return dispatch_walltime(&walltime, 0);
}複製程式碼dispatch_walltime函式是由POSIX中使用的struct timespec型別的時間得到dispatch_time_t型別的值。dispatch_time函式通常用於計算相對時間，而dispatch_walltime函式用於計算絕對時間。
這段程式碼其實很簡單，就是把date的時間轉換成一個dispatch_time_t型別的。由NSDate類物件獲取能傳遞給dispatch_after函式的dispatch_time_t型別的值。
- (RACDisposable *)after:(NSDate *)date repeatingEvery:(NSTimeInterval)interval withLeeway:(NSTimeInterval)leeway schedule:(void (^)(void))block {
NSCParameterAssert(date != nil);
NSCParameterAssert(interval > 0.0 && interval < INT64_MAX / NSEC_PER_SEC);
NSCParameterAssert(leeway >= 0.0 && leeway < INT64_MAX / NSEC_PER_SEC);
NSCParameterAssert(block != NULL);
uint64_t intervalInNanoSecs = (uint64_t)(interval * NSEC_PER_SEC);
uint64_t leewayInNanoSecs = (uint64_t)(leeway * NSEC_PER_SEC);
dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, self.queue);
dispatch_source_set_timer(timer, [self.class wallTimeWithDate:date], intervalInNanoSecs, leewayInNanoSecs);
dispatch_source_set_event_handler(timer, block);
dispatch_resume(timer);
return [RACDisposable disposableWithBlock:^{
dispatch_source_cancel(timer);
}];
}複製程式碼after: repeatingEvery: withLeeway: schedule:方法裡面的實現就是用GCD在self.queue上建立了一個Timer，時間間隔是interval，修正時間是leeway。
leeway這個引數是為dispatch source指定一個期望的定時器事件精度，讓系統能夠靈活地管理並喚醒核心。例如系統可以使用leeway值來提前或延遲觸發定時器，使其更好地與其它系統事件結合。建立自己的定時器時，應該儘量指定一個leeway值。不過就算指定leeway值為0，也不能完完全全期望定時器能夠按照精確的納秒來觸發事件。
這個定時器在interval執行入參閉包。在取消任務的時候呼叫dispatch_source_cancel取消定時器timer。
5. RACTargetQueueScheduler
這個子類在分析mainThreadScheduler方法的時候，詳細分析過了，這裡不再贅述。
三. RACScheduler是如何“取消”併發任務的
既然RACScheduler是對GCD的封裝，那麼在GCD的上層可以實現一些GCD所無法完成的“特性”。這裡的“特性”是打引號的，因為底層是GCD，上層的特性只能通過一些特殊手段來實現看似是新的特性。在這一點上，RACScheduler就實現了GCD沒有的特性——“取消”任務。
Operation Queues ：
相對 GCD來說，使用 Operation Queues 會增加一點點額外的開銷，但是卻換來了非常強大的靈活性和功能，它可以給 operation 之間新增依賴關係、取消一個正在執行的 operation 、暫停和恢復 operation queue 等；
GCD：
是一種更輕量級的，以 FIFO的順序執行併發任務的方式，使用 GCD時我們可以並不關心任務的排程情況，而讓系統幫我們自動處理。但是 GCD的缺陷也是非常明顯的，想要給任務之間新增依賴關係、取消或者暫停一個正在執行的任務時就會變得非常棘手。
既然GCD不方便取消一個任務，那麼RACScheduler是怎麼做到的呢？
這就體現在RACQueueScheduler上。回頭看看RACQueueScheduler的schedule:實現 和 after: schedule:實現。
最核心的程式碼:
dispatch_async(self.queue, ^{
if (disposable.disposed) return;
[self performAsCurrentScheduler:block];
});複製程式碼在呼叫performAsCurrentScheduler:之前，加了一個判斷，判斷當前是否取消了任務，如果取消了任務，就return，不會呼叫block閉包。這樣就實現了取消任務的“假象”。
四. RACScheduler是如何和RAC其他元件進行完美整合的
在整個ReactiveCocoa中，利用RACScheduler實現了很多操作，和RAC是深度整合的。這裡就來總結總結ReactiveCocoa中總共有哪些地方用到了RACScheduler。
在ReactiveCocoa 中全域性搜尋RACScheduler，遍歷完所有庫，RACScheduler就用在以下10個類中。下面就來看看是如何用在這些地方的。
從下面這些地方使用了Scheduler中，我們就可以瞭解到哪些操作是在子執行緒，哪些是在主執行緒。區分出了這些，對於執行緒不安全的操作，我們就能心有成足的處理好它們，讓它們回到主執行緒中去操作，這樣就可以減少很多莫名的Crash。這些Crash都是因為執行緒問題導致的。
1. 在RACCommand中
- (id)initWithEnabled:(RACSignal *)enabledSignal signalBlock:(RACSignal * (^)(id input))signalBlock複製程式碼這個方法十分複雜，裡面用到了RACScheduler.immediateScheduler，deliverOn:RACScheduler.mainThreadScheduler。具體的原始碼分析會在下一篇RACCommand原始碼分析裡面詳細分析。
- (RACSignal *)execute:(id)input複製程式碼在這個方法中，會呼叫subscribeOn:RACScheduler.mainThreadScheduler。
2. 在RACDynamicSignal中
- (RACDisposable *)subscribe:(id<RACSubscriber>)subscriber {
NSCParameterAssert(subscriber != nil);
RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable];
subscriber = [[RACPassthroughSubscriber alloc] initWithSubscriber:subscriber signal:self disposable:disposable];
if (self.didSubscribe != NULL) {
RACDisposable *schedulingDisposable = [RACScheduler.subscriptionScheduler schedule:^{
RACDisposable *innerDisposable = self.didSubscribe(subscriber);
[disposable addDisposable:innerDisposable];
}];
[disposable addDisposable:schedulingDisposable];
}
return disposable;
}複製程式碼在RACDynamicSignal的subscribe:訂閱過程中會用到subscriptionScheduler。於是對這個scheduler呼叫schedule:就會執行下面這段程式碼：
- (RACDisposable *)schedule:(void (^)(void))block {
NSCParameterAssert(block != NULL);
if (RACScheduler.currentScheduler == nil) return [self.backgroundScheduler schedule:block];
block();
return nil;
}複製程式碼如果currentScheduler不為空，閉包會在currentScheduler中執行，如果currentScheduler為空，閉包就會在backgroundScheduler中執行，這是一個Global Dispatch Queue，優先順序是RACSchedulerPriorityDefault。
同理，在RACEmptySignal，RACErrorSignal，RACReturnSignal，RACSignal的相關的signal的訂閱中也都會呼叫subscriptionScheduler。
3. 在RACBehaviorSubject中
- (RACDisposable *)subscribe:(id<RACSubscriber>)subscriber {
RACDisposable *subscriptionDisposable = [super subscribe:subscriber];
RACDisposable *schedulingDisposable = [RACScheduler.subscriptionScheduler schedule:^{
@synchronized (self) {
[subscriber sendNext:self.currentValue];
}
}];
return [RACDisposable disposableWithBlock:^{
[subscriptionDisposable dispose];
[schedulingDisposable dispose];
}];
}複製程式碼在RACBehaviorSubject的subscribe:訂閱過程中會用到subscriptionScheduler。於是對這個scheduler呼叫schedule:，程式碼在上面分析過了。
同理，如果currentScheduler不為空，閉包會在currentScheduler中執行，如果currentScheduler為空，閉包就會在backgroundScheduler中執行，這是一個Global Dispatch Queue，優先順序是RACSchedulerPriorityDefault。
4. 在RACReplaySubject中
它的訂閱也同上面訊號的訂閱一樣，會呼叫subscriptionScheduler。
由於RACReplaySubject是在子執行緒上，所以建議在使用Core Data這些不安全庫的時候一定要記得加上deliverOn。
5. 在RACSequence中
在RACSequence中，以下兩個方法用到了RACScheduler：
- (RACSignal *)signal {
return [[self signalWithScheduler:[RACScheduler scheduler]] setNameWithFormat:@"[%@] -signal", self.name];
}複製程式碼
- (RACSignal *)signalWithScheduler:(RACScheduler *)scheduler {
return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
__block RACSequence *sequence = self;
return [scheduler scheduleRecursiveBlock:^(void (^reschedule)(void)) {
if (sequence.head == nil) {
[subscriber sendCompleted];
return;
}
[subscriber sendNext:sequence.head];
sequence = sequence.tail;
reschedule();
}];
}] setNameWithFormat:@"[%@] -signalWithScheduler: %@", self.name, scheduler];
}複製程式碼上面兩個方法會呼叫RACScheduler中的scheduleRecursiveBlock:方法。關於這個方法的原始碼分析可以看RACSequence的原始碼分析。
6. 在RACSignal+Operations中
這裡總共有9個方法用到了Scheduler。
第一個方法：
static RACDisposable *subscribeForever (RACSignal *signal, void (^next)(id), void (^error)(NSError *, RACDisposable *), void (^completed)(RACDisposable *))複製程式碼在上面這個方法裡面用到了
RACScheduler *recursiveScheduler = RACScheduler.currentScheduler ?: [RACScheduler scheduler];複製程式碼取出currentScheduler或者一個Global Dispatch Queue，然後呼叫scheduleRecursiveBlock:。
第二個方法：
- (RACSignal *)throttle:(NSTimeInterval)interval valuesPassingTest:(BOOL (^)(id next))predicate複製程式碼在上面這個方法中會呼叫
RACScheduler *scheduler = [RACScheduler scheduler];
RACScheduler *delayScheduler = RACScheduler.currentScheduler ?: scheduler複製程式碼在delayScheduler中呼叫afterDelay: schedule:方法，這也是throttle:valuesPassingTest:方法實現的很重要的一步。
第三個方法：
- (RACSignal *)delay:(NSTimeInterval)interval複製程式碼由於這是一個延遲方法，肯定是會呼叫Scheduler的after方法。
RACScheduler *delayScheduler = RACScheduler.currentScheduler ?: scheduler;
RACDisposable *schedulerDisposable = [delayScheduler afterDelay:interval schedule:block];複製程式碼RACScheduler.currentScheduler ?: scheduler 這個判斷在上述幾個時間相關的方法都用到了。
所以，這裡給一個建議：
delay由於不一定會回到當前執行緒中，所以delay之後再去訂閱可能就在子執行緒中去執行。所以使用delay的時候最好追加一個deliverOn。
第四個方法：
- (RACSignal *)bufferWithTime:(NSTimeInterval)interval onScheduler:(RACScheduler *)scheduler複製程式碼在這個方法中理所當然的需要呼叫[scheduler afterDelay:interval schedule:flushValues]這個方法，來達到延遲的目的，從而實現緩衝buffer的效果。
第五個方法：
+ (RACSignal *)interval:(NSTimeInterval)interval onScheduler:(RACScheduler *)scheduler複製程式碼第六個方法：
+ (RACSignal *)interval:(NSTimeInterval)interval onScheduler:(RACScheduler *)scheduler withLeeway:(NSTimeInterval)leeway { }複製程式碼第五個方法 和 第六個方法都用傳進去的入參scheduler去呼叫after: repeatingEvery: withLeeway: schedule:方法。
第七個方法：
- (RACSignal *)timeout:(NSTimeInterval)interval onScheduler:(RACScheduler *)scheduler { }複製程式碼在這個方法中會用入參scheduler呼叫afterDelay: schedule:，延遲一段時候後，執行[disposable dispose]，從而也實現了超時傳送sendError:。
第八個方法：
- (RACSignal *)deliverOn:(RACScheduler *)scheduler { }複製程式碼第九個方法：
- (RACSignal *)subscribeOn:(RACScheduler *)scheduler { }複製程式碼第八個方法 和 第九個方法都是根據入參scheduler去呼叫schedule:方法。入參是什麼型別的scheduler決定了schedule:執行在哪個queue上。
7. 在RACSignal中
在RACSignal也有積極計算和惰性求值的訊號。
+ (RACSignal *)startEagerlyWithScheduler:(RACScheduler *)scheduler block:(void (^)(id<RACSubscriber> subscriber))block {
NSCParameterAssert(scheduler != nil);
NSCParameterAssert(block != NULL);
RACSignal *signal = [self startLazilyWithScheduler:scheduler block:block];
[[signal publish] connect];
return [signal setNameWithFormat:@"+startEagerlyWithScheduler: %@ block:", scheduler];
}複製程式碼startEagerlyWithScheduler中會呼叫startLazilyWithScheduler產生一個訊號signal，然後緊接著轉換成熱訊號。通過startEagerlyWithScheduler產生的訊號就直接是一個熱訊號。
+ (RACSignal *)startLazilyWithScheduler:(RACScheduler *)scheduler block:(void (^)(id<RACSubscriber> subscriber))block {
NSCParameterAssert(scheduler != nil);
NSCParameterAssert(block != NULL);
RACMulticastConnection *connection = [[RACSignal
createSignal:^ id (id<RACSubscriber> subscriber) {
block(subscriber);
return nil;
}]
multicast:[RACReplaySubject subject]];
return [[[RACSignal
createSignal:^ id (id<RACSubscriber> subscriber) {
[connection.signal subscribe:subscriber];
[connection connect];
return nil;
}]
subscribeOn:scheduler]
setNameWithFormat:@"+startLazilyWithScheduler: %@ block:", scheduler];
}複製程式碼上述是startLazilyWithScheduler:的原始碼實現，在這個方法中和startEagerlyWithScheduler最大的區別就出來了，connect方法在return的訊號中，所以Lazily就體現在，通過startLazilyWithScheduler建立出來的訊號，只有訂閱它之後才能呼叫到connect，轉變成熱訊號。
在這裡呼叫了subscribeOn:scheduler，這裡用到了scheduler。
8. 在NSData+RACSupport中
+ (RACSignal *)rac_readContentsOfURL:(NSURL *)URL options:(NSDataReadingOptions)options scheduler:(RACScheduler *)scheduler {
NSCParameterAssert(scheduler != nil);
RACReplaySubject *subject = [RACReplaySubject subject];
[subject setNameWithFormat:@"+rac_readContentsOfURL: %@ options: %lu scheduler: %@", URL, (unsigned long)options, scheduler];
[scheduler schedule:^{
NSError *error = nil;
NSData *data = [[NSData alloc] initWithContentsOfURL:URL options:options error:&error];
if (data == nil) {
[subject sendError:error];
} else {
[subject sendNext:data];
[subject sendCompleted];
}
}];
return subject;
}複製程式碼在這個方法中，會傳入RACQueueScheduler或者RACTargetQueueScheduler的RACScheduler。那麼呼叫schedule方法就會執行到這裡：
- (RACDisposable *)schedule:(void (^)(void))block {
NSCParameterAssert(block != NULL);
RACDisposable *disposable = [[RACDisposable alloc] init];
dispatch_async(self.queue, ^{
if (disposable.disposed) return;
[self performAsCurrentScheduler:block];
});
return disposable;
}複製程式碼9. 在NSString+RACSupport中
+ (RACSignal *)rac_readContentsOfURL:(NSURL *)URL usedEncoding:(NSStringEncoding *)encoding scheduler:(RACScheduler *)scheduler {
NSCParameterAssert(scheduler != nil);
RACReplaySubject *subject = [RACReplaySubject subject];
[subject setNameWithFormat:@"+rac_readContentsOfURL: %@ usedEncoding:scheduler: %@", URL, scheduler];
[scheduler schedule:^{
NSError *error = nil;
NSString *string = [NSString stringWithContentsOfURL:URL usedEncoding:encoding error:&error];
if (string == nil) {
[subject sendError:error];
} else {
[subject sendNext:string];
[subject sendCompleted];
}
}];
return subject;
}複製程式碼同NSData+RACSupport中的rac_readContentsOfURL: options: scheduler:一樣，也會傳入RACQueueScheduler或者RACTargetQueueScheduler的RACScheduler。
10. 在NSUserDefaults+RACSupport中
RACScheduler *scheduler = [RACScheduler scheduler];複製程式碼在這個方法中也會新建RACTargetQueueScheduler，一個Global Dispatch Queue。優先順序是RACSchedulerPriorityDefault。
最後
關於RACScheduler底層實現分析都已經分析完成。最後請大家多多指教。
本次徵文活動的連結：
gold.xitu.io/post/58522d…