Question regarding implementation

[MikePendo]

Hi
I have looked through the code and was wondering about some parts of it, I would really appreciate if you could share some light
when creating a promise with the following code: link

+ (instancetype)onQueue:(dispatch_queue_t)queue async:(FBLPromiseAsyncWorkBlock)work {
  NSParameterAssert(queue);
  NSParameterAssert(work);

  FBLPromise *promise = [[self alloc] initPending];
  dispatch_group_async(FBLPromise.dispatchGroup, queue, ^{
  work(
        ^(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];
          }
        },
        ^(NSError *error) {
          [promise reject:error];
        });
  });
  return promise;
}

1. What is the purpose of dispatch_group_async(FBLPromise.dispatchGroup? I mean why dispatch_group_async what the purpose of groupes (I feel it like synchronizes the calls )
2. if the queue was asynchronous (not serial by default) what guarantee that work will be executed after the calling code

[shoumikhin]

Hi Michael,

There's a section in the docs on how the dispatch group can help with testing. And you can use any dispatch queue, including a concurrent one to run the work block. E.g. see how one is set as a default. Afaik, the dispatch_async API guarantees it always completes before the block argument gets control.

Thanks.

[MikePendo]

Hi @shoumikhin ,
Thanks a lot for your help.
I am not sure what you meant by
Afaik, the dispatch_async API guarantees it always completes before the block argument gets control.

My point was, assuming u have a lot of nested then: following the async:, how u guarantee the work inside the async: wont start its execution before the nested then: have all bee finished and all the promises are ready to run their observers code? (Am I making my question clear? I mean is my concern legit).

Another point (out of curiosity ) u r always using dispatch with groups, what was the the benefit to use groups over just dispatch_async? I mean I dont see see and wait or notify for those groups later on

[MikePendo]

@shoumikhin
Sorry too bothering you but for instance if I have the following test:

- (void)testAsyncDifferentQueues {
    
    dispatch_queue_attr_t attributesPromise = dispatch_queue_attr_make_with_qos_class(DISPATCH_QUEUE_SERIAL,QOS_CLASS_USER_INITIATED,0);
    dispatch_queue_attr_t attributesRunFrom = dispatch_queue_attr_make_with_qos_class(DISPATCH_QUEUE_SERIAL,QOS_CLASS_BACKGROUND,0);
    dispatch_queue_t serialForPromise = dispatch_queue_create("serial.promise", attributesPromise);
    dispatch_queue_t serialRunFrom = dispatch_queue_create("serial.runFrom", attributesRunFrom);
    [FBLPromise setDefaultDispatchQueue:serialForPromise];
    
    dispatch_async(serialRunFrom, ^{
        [[FBLPromise async:^(FBLPromiseFulfillBlock fulfill, FBLPromiseRejectBlock __unused _) {
                  fulfill(@42);
        }] then:^id (id value) {
            NSLog(@"do I come here");
            return nil;
        }];
        NSLog(@"Should finish before then");
    });   
    [[NSRunLoop mainRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:1]];
}

What guarantee that "Should finish before then" will be done before "do I come here".
it indeed what happens but I am not sure what guarantee that. dispatch_group_async?