知识点总结性文章
创作不易，请珍惜，之后会持续更新，不断完善
个人比较喜欢做笔记和写总结，毕竟好记性不如烂笔头哈哈，这些文章记录了我的IOS成长历程，希望能与大家一起进步
温馨提示：由于简书不支持目录跳转，大家可通过command + F 输入目录标题后迅速寻找到你所需要的内容

目录

• 一、多任务回调
• 二、Promises 的使用
• 三、Promises原理解析

一、多任务回调

回调任务是很正常的现象，比如说购买一个商品，需要下单，然后等后台返回。单一任务，通常只需要一个block，非常清晰，以上面的下单为例，传给网络层一个block，购买完成之后回调即可。

但是出现多个任务的时候，逻辑就开始有分支，同样以购买商品为例，在下单完成后，需要和SDK发起支付，然后根据支付结果再进行一些提示： 任务1是下单，执行完回调error指针（或者状态码）表示完成状态，同时待会下单信息，此时产生一个分支，成功继续下一步，失败执行错误block；然后是执行任务2购买，执行异步的支付，根据支付结果又会产生一个分支。当连续的任务超过2个之后，分支会导致代码逻辑非常混乱。

简单画一个流程图来分析，上述的逻辑变得复杂的原因是因为每一级的block需要处理下一级block的失败情况，导致逻辑分支的增多。其实所有的失败处理都是类似的：打日志、提示用户，可以放在一起统一处理。然后把任务一、任务二等串行执行，流程就非常清晰。

Promises就是用来辅助实现这样设计的库。实现的代码效果如下：

- (void)workflow {
    [[[[self order:@"order_id"] then:^id _Nullable(NSString * _Nullable value) {
        return [self pay:value];
    }] then:^id _Nullable(id  _Nullable value) {
        return [self check:value];
    }] catch:^(NSError * _Nonnull error) {
        NSLog(@"error: %@", error);
    }];
}

二、Promises 的使用

Promises库的引入非常简单，可以使用CocoaPod，Podfile如下：

pod 'PromisesObjC'

按照Promise设计模式的规范，每一个Promise应该有三种状态：pending(等待)、fulfilled(完成)、rejected(失败)；对应到Promises分别是：

[FBLPromise pendingPromise]; // pending等待
[FBLPromise resolvedWith:@"anyString"]; // fulfilled完成
[FBLPromise resolvedWith:[NSError new]]; // rejected失败

实际使用中，我们更多使用的Promises库已经提供好的便捷函数，启动一个异步任务：

[FBLPromise onQueue:dispatch_get_main_queue()
              async:^(FBLPromiseFulfillBlock fulfill,
                      FBLPromiseRejectBlock reject) {
    BOOL success = arc4random() % 2;
    if (success) {
        fulfill(@"success");
    }
    else {
        reject([NSError errorWithDomain:@"learn_promises_error" code:-1 userInfo:nil]);
    }
}];

或者简单使用do方法：

[FBLPromise do:^id _Nullable{
    BOOL success = random() % 2;
    if (success) {
        return @"success";
    }
    else {
        return [NSError errorWithDomain:@"learn_promises_error" code:-1 userInfo:nil];
    }
}];

不管是async方法还是do方法，他们的返回值都是创建一个Promise对象，可以在Promise对象后面挂一个then方法，表示这个Promise执行完毕之后，要继续执行的任务：

[[[FBLPromise do:^id _Nullable{
    BOOL success = arc4random() % 2;
    return success ? @"do_success" : [NSError errorWithDomain:@"learn_promises_do_error" code:-1 userInfo:nil];
}] then:^id _Nullable(id  _Nullable value) {
    BOOL success = arc4random() % 2;
    return success ? @"then_success" : [NSError errorWithDomain:@"learn_promises_then_error" code:-1 userInfo:nil];
}] catch:^(NSError * _Nonnull error) {
    NSLog(@"error: %@", error);
}];

上面的catch方法表示统一的error处理。promise在完成任务之后，如果满足下面的条件会调用then的方法：

• 直接调用fulfill；
• 在do方法中返回一个值（不能为error）；
• 在then方法中返回一个值；

调用reject方法或者返回一个NSError对象，都会转到catch方法处理。用上面的do、then、catch方法组合，就完成多个异步任务的依赖执行：

- (void)workflow {
    [[[[self order:@"order_id"] then:^id _Nullable(NSString * _Nullable value) {
        return [self pay:value];
    }] then:^id _Nullable(id  _Nullable value) {
        return [self check:value];
    }] catch:^(NSError * _Nonnull error) {
        NSLog(@"error: %@", error);
    }];
}

- (FBLPromise<NSString *> *)order:(NSString *)orderParam {
    return [FBLPromise do:^id _Nullable{
        return @"order_success";
    }];
}

- (FBLPromise<NSString *> *)pay:(NSString *)payParam {
    return  [FBLPromise do:^id _Nullable{
        BOOL success = arc4random() % 2;
        return success ? @"pay_success" : [NSError errorWithDomain:@"pay_error" code:-1 userInfo:nil];
    }];
}

- (FBLPromise<NSString *> *)check:(NSString *)checkParam {
    return  [FBLPromise do:^id _Nullable{
        return @"check success";
    }];
}

Promises还提供了很多附加特性，以All和Any为例：All是所有Promise都fulfill才算完成；Any是任何一个Promise完成都会执行fulfill；

- (void)testAllAndAny {
    NSMutableArray *arr = [NSMutableArray new];
    [arr addObject:[self work1]];
    [arr addObject:[self work2]];
    
    [[[FBLPromise all:arr] then:^id _Nullable(NSArray * _Nullable value) {
        NSLog(@"then, value:%@", value);
        return value;
    }] catch:^(NSError * _Nonnull error) {
        NSLog(@"all error:%@", error);
    }];
    
    [[[FBLPromise any:arr] then:^id _Nullable(NSArray * _Nullable value) {
        NSLog(@"then, value:%@", value);
        return value;
    }] catch:^(NSError * _Nonnull error) {
        NSLog(@"any error:%@", error);
    }];
}

- (FBLPromise<NSString *> *)work1 {
    return [FBLPromise do:^id _Nullable{
        BOOL success = arc4random() % 2;
        return success ? @"work1 success" : [NSError errorWithDomain:@"work1_error" code:-1 userInfo:nil];
    }];
}

- (FBLPromise<NSNumber *> *)work2 {
    return  [FBLPromise do:^id _Nullable{
        BOOL success = arc4random() % 2;
        return success ? @"work2 success" : [NSError errorWithDomain:@"work2_error" code:-1 userInfo:nil];
    }];
}

三、Promises原理解析

Promises库的设计很简单，基于Promise设计模式和iOS的GCD来实现。整个库由Promise.m/.h和他的Catagory组成。Catagory都是附加特性，基于Promise.m/.h提供的方法做扩展，所以这里重点解析下Promise.m/h。Promise类public头文件只有寥寥数个方法：

// 静态方法
[FBLPromise pendingPromise]; // pending等待
[FBLPromise resolvedWith:@"anyString"]; // fulfilled完成
[FBLPromise resolvedWith:[NSError new]]; // rejected失败

// 实例方法
- (void)fulfill:(nullable Value)value; // 完成一个promise
- (void)reject:(NSError *)error;// rejected一个promise

重点在于private.h提供的两个方法。

对一个promise添加fulfill和reject的回调。observeOnQueue方法是promise的实例方法，根据promise当前的状态，如果是fulfilled或者rejected状态则会dispatch_group_async到下一次执行对应的onFulfill和onReject回调；如果是pending状态则会创建_observers数组，往_observers数组中添加一个block回调，当promise执行完毕的时候，根据state选择onFulfill或者onReject回调。

- (void)observeOnQueue:(dispatch_queue_t)queue
               fulfill:(FBLPromiseOnFulfillBlock)onFulfill
                reject:(FBLPromiseOnRejectBlock)onReject NS_SWIFT_UNAVAILABLE("");

创建一个promise，并设置fulfill、reject方法为传进来的block。

- (FBLPromise *)chainOnQueue:(dispatch_queue_t)queue
              chainedFulfill:(FBLPromiseChainedFulfillBlock)chainedFulfill
               chainedReject:(FBLPromiseChainedRejectBlock)chainedReject NS_SWIFT_UNAVAILABLE("");

chainOnQueue方法同样是promise的实例方法，返回的是一个FBLPromise的对象（状态是pending）。方法首先创建的是promise对象，接着创建了resolver的回调，然后调用observeOnQueue方法。

当self（也是一个promise）执行完毕后，会根据fulfill、reject回调类型接着执行chainedFulfill、chainedReject；最后将结果抛给resolver执行，resolver会根据返回值value进行判断，如果仍是promise则递归执行，否则直接调用fulfill方法。fulfill方法则会判断value是否为NSError，如果是NSError则转为reject，否则将状态改为Fulfilled，并且通知observer数组。

- (FBLPromise *)chainOnQueue:(dispatch_queue_t)queue
chainedFulfill:(FBLPromiseChainedFulfillBlock)chainedFulfill
chainedReject:(FBLPromiseChainedRejectBlock)chainedReject {
    NSParameterAssert(queue);
    
    FBLPromise *promise = [[FBLPromise alloc] initPending];
    __auto_type resolver = ^(id __nullable value) {
        if ([value isKindOfClass:[FBLPromise class]]) {
            [(FBLPromise *)value observeOnQueue:queue
                                        fulfill:^(id __nullable value) {
                [promise fulfill:value];
            }
                                         reject:^(NSError *error) {
                [promise reject:error];
            }];
        } else {
            [promise fulfill:value];
        }
    };
    [self observeOnQueue:queue
                 fulfill:^(id __nullable value) {
        value = chainedFulfill ? chainedFulfill(value) : value;
        resolver(value);
    }
                  reject:^(NSError *error) {
        id value = chainedReject ? chainedReject(error) : error;
        resolver(value);
    }];
    return promise;
}

Promises中的dispatch_group_enter()和 dispatch_group_leave() 是成对使用，但是和平时使用GCD不同，这里并没有用到dispath_group_notify方法。在刚开始看Promises源码时，产生过一个疑问，为什么所有Promises的操作要放在同一个group内？直到发现FBLWaitForPromisesWithTimeout方法，里面有一个dispatch_group_wait方法（等待group中所有block执行完毕，或者在指定时间结束后回调）。

dispatch_group_wait方法与dispath_group_notify方法类似，只是多了一个超时时间，如果调用dispatch_group_wait(DISPATCH_TIME_FOREVER)则和dispath_group_notify方法一样。

+ (dispatch_group_t)dispatchGroup {
    static dispatch_group_t gDispatchGroup;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        gDispatchGroup = dispatch_group_create();
    });
    return gDispatchGroup;
}

附加的特性有很多，类似Retry、Delay等，但实际使用中Promise用do、then、catch、async等少数几个已经可以满足需求。能够实现Promise设计模式的库比较多，Promises是性能和接口调用清晰度都比较不错的。使用设计模式可以简化逻辑代码，同时也使得代码的健壮性更强。