Waiting until two async blocks are executed before starting another block

Question

When using GCD  we want to wait until two async blocks are executed and done before moving on to the next steps of execution  What is the best way to do that   We tried the following  but it doesn t seem to work   dispatch async dispatch get global queue DISPATCH QUEUE PRIORITY HIGH  0              block1       dispatch async dispatch get global queue DISPATCH QUEUE PRIORITY HIGH  0              block2         wait until both the block1 and block2 are done before start block3    how to do that   dispatch sync dispatch get global queue DISPATCH QUEUE PRIORITY HIGH  0              block3

User · Answer

Answers above are all cool  but they all missed one thing  group executes tasks blocks  in the thread where it entered when you use dispatch group enter dispatch group leave   -  IBAction buttonAction  id sender         dispatch queue t demoQueue   dispatch queue create  com demo group   DISPATCH QUEUE CONCURRENT         dispatch async demoQueue             dispatch group t demoGroup   dispatch group create            for int i   0  i  lt  10  i                dispatch group enter demoGroup              self testMethod i                      block                           dispatch group leave demoGroup                                               dispatch group notify demoGroup  dispatch get main queue                 NSLog   All group tasks are done                                      -  void testMethod  NSInteger index block  void    void  completeBlock         NSLog   Group task started    ld   index         NSLog   Current thread is    thread    NSThread isMainThread      main      not main           NSThread sleepForTimeInterval 1 f          if completeBlock            completeBlock                    this runs in the created concurrent queue demoQueue  If i dont create any queue  it runs in main thread   -  IBAction buttonAction  id sender       dispatch group t demoGroup   dispatch group create        for int i   0  i  lt  10  i            dispatch group enter demoGroup          self testMethod i                  block                       dispatch group leave demoGroup                                   dispatch group notify demoGroup  dispatch get main queue             NSLog   All group tasks are done                        -  void testMethod  NSInteger index block  void    void  completeBlock         NSLog   Group task started    ld   index         NSLog   Current thread is    thread    NSThread isMainThread      main      not main           NSThread sleepForTimeInterval 1 f          if completeBlock            completeBlock                    and there s a third way to make tasks executed in another thread   -  IBAction buttonAction  id sender         dispatch queue t demoQueue   dispatch queue create  com demo group   DISPATCH QUEUE CONCURRENT             dispatch async demoQueue             weak ViewController  weakSelf   self        dispatch group t demoGroup   dispatch group create          for int i   0  i  lt  10  i              dispatch group enter demoGroup           dispatch async demoQueue                weakSelf testMethod i                          block                               dispatch group leave demoGroup                                                           dispatch group notify demoGroup  dispatch get main queue               NSLog   All group tasks are done                                     Of course  as mentioned you can use dispatch group async to get what you want

User · Answer

I know you asked about GCD  but if you wanted  NSOperationQueue also handles this sort of stuff really gracefully  e g    NSOperationQueue  queue     NSOperationQueue alloc  init    NSOperation  completionOperation    NSBlockOperation blockOperationWithBlock        NSLog   Starting 3         NSOperation  operation   operation    NSBlockOperation blockOperationWithBlock        NSLog   Starting 1        sleep 7       NSLog   Finishing 1          completionOperation addDependency operation    queue addOperation operation    operation    NSBlockOperation blockOperationWithBlock        NSLog   Starting 2        sleep 5       NSLog   Finishing 2          completionOperation addDependency operation    queue addOperation operation     queue addOperation completionOperation

User · Answer

The first answer is essentially correct  but if you want the very simplest way to accomplish the desired result  here s a stand-alone code example demonstrating how to do it with a semaphore  which is also how dispatch groups work behind the scenes  JFYI     include  lt dispatch dispatch h gt   include  lt stdio h gt   main             dispatch queue t myQ   dispatch queue create  my conQ   DISPATCH QUEUE CONCURRENT           dispatch semaphore t mySem   dispatch semaphore create 0            dispatch async myQ     printf  Hi I m block one  n    sleep 2   dispatch semaphore signal mySem              dispatch async myQ     printf  Hi I m block two  n    sleep 4   dispatch semaphore signal mySem              dispatch async myQ     dispatch semaphore wait mySem  DISPATCH TIME FOREVER   printf  Hi  I m the final block  n                dispatch main

User · Answer

Another GCD alternative is a barrier   dispatch queue t queue   dispatch queue create  com company app queue   DISPATCH QUEUE CONCURRENT    dispatch async queue          NSLog   start one  n          sleep 4         NSLog   end one  n         dispatch async queue           NSLog   start two  n          sleep 2         NSLog   end two  n          dispatch barrier async queue           NSLog   Hi  I m the final block  n            Just create a concurrent queue  dispatch your two blocks  and then dispatch the final block with barrier  which will make it wait for the other two to finish

User · Answer

Use dispatch groups  see here for an example   Waiting on Groups of Queued Tasks  in the  Dispatch Queues  chapter of Apple s iOS Developer Library s Concurrency Programming Guide  Your example could look something like this   dispatch group t group   dispatch group create     dispatch group async group dispatch get global queue DISPATCH QUEUE PRIORITY HIGH  0              block1     NSLog   Block1         NSThread sleepForTimeInterval 5 0       NSLog   Block1 End          dispatch group async group dispatch get global queue DISPATCH QUEUE PRIORITY HIGH  0              block2     NSLog   Block2         NSThread sleepForTimeInterval 8 0       NSLog   Block2 End         dispatch group notify group dispatch get global queue DISPATCH QUEUE PRIORITY HIGH  0              block3     NSLog   Block3            only for non-ARC projects  handled automatically in ARC-enabled projects  dispatch release group     and could produce output like this   2012-08-11 16 10 18 049 Dispatch 11858 1e03  Block1 2012-08-11 16 10 18 052 Dispatch 11858 1d03  Block2 2012-08-11 16 10 23 051 Dispatch 11858 1e03  Block1 End 2012-08-11 16 10 26 053 Dispatch 11858 1d03  Block2 End 2012-08-11 16 10 26 054 Dispatch 11858 1d03  Block3

User · Answer

Not to say other answers are not great for certain circumstances  but this is one snippet I always user from Google   -  void runSigninThenInvokeSelector  SEL signInDoneSel         if  signInDoneSel             self performSelector signInDoneSel

User · Answer

With Swift 5 1  Grand Central Dispatch offers many ways to solve your problem  According to your needs  you may choose one of the seven patterns shown in the following Playground snippets      1  Using DispatchGroup  DispatchGroup s notify qos flags queue execute   and DispatchQueue s async group qos flags execute    The Apple Developer Concurrency Programming Guide states about DispatchGroup      Dispatch groups are a way to block a thread until one or more tasks finish executing  You can use this behavior in places where you cannot make progress until all of the specified tasks are complete  For example  after dispatching several tasks to compute some data  you might use a group to wait on those tasks and then process the results when they are done    import Foundation import PlaygroundSupport  PlaygroundPage current needsIndefiniteExecution   true  let queue   DispatchQueue label   com company app queue   attributes   concurrent  let group   DispatchGroup    queue async group  group        print   1 started       Thread sleep forTimeInterval  5      print   1 finished      queue async group  group        print   2 started       Thread sleep forTimeInterval  2      print   2 finished      group notify queue  queue        print   3 finished          prints    1 started   2 started   2 finished   1 finished   3 finished          2  Using DispatchGroup  DispatchGroup s wait    DispatchGroup s enter   and DispatchGroup s leave    import Foundation import PlaygroundSupport  PlaygroundPage current needsIndefiniteExecution   true  let queue   DispatchQueue label   com company app queue   attributes   concurrent  let group   DispatchGroup    group enter   queue async       print   1 started       Thread sleep forTimeInterval  5      print   1 finished       group leave      group enter   queue async       print   2 started       Thread sleep forTimeInterval  2      print   2 finished       group leave      queue async       group wait       print   3 finished          prints    1 started   2 started   2 finished   1 finished   3 finished       Note that you can also mix DispatchGroup wait   with DispatchQueue async group qos flags execute   or mix DispatchGroup enter   and DispatchGroup leave   with DispatchGroup notify qos flags queue execute        3  Using Dispatch Work Item Flags barrier and DispatchQueue s async group qos flags execute    Grand Central Dispatch Tutorial for Swift 4  Part 1 2 article from Raywenderlich com gives a definition for barriers      Dispatch barriers are a group of functions acting as a serial-style bottleneck when working with concurrent queues  When you submit a DispatchWorkItem to a dispatch queue you can set flags to indicate that it should be the only item executed on the specified queue for that particular time  This means that all items submitted to the queue prior to the dispatch barrier must complete before the DispatchWorkItem will execute    Usage   import Foundation import PlaygroundSupport  PlaygroundPage current needsIndefiniteExecution   true  let queue   DispatchQueue label   com company app queue   attributes   concurrent   queue async       print   1 started       Thread sleep forTimeInterval  5      print   1 finished      queue async       print   2 started       Thread sleep forTimeInterval  2      print   2 finished      queue async flags   barrier        print   3 finished          prints    1 started   2 started   2 finished   1 finished   3 finished          4  Using DispatchWorkItem  Dispatch Work Item Flags s barrier and DispatchQueue s async execute    import Foundation import PlaygroundSupport  PlaygroundPage current needsIndefiniteExecution   true  let queue   DispatchQueue label   com company app queue   attributes   concurrent   queue async       print   1 started       Thread sleep forTimeInterval  5      print   1 finished      queue async       print   2 started       Thread sleep forTimeInterval  2      print   2 finished      let dispatchWorkItem   DispatchWorkItem qos   default  flags   barrier        print   3 finished      queue async execute  dispatchWorkItem       prints    1 started   2 started   2 finished   1 finished   3 finished          5  Using DispatchSemaphore  DispatchSemaphore s wait   and DispatchSemaphore s signal    Soroush Khanlou wrote the following lines in The GCD Handbook blog post      Using a semaphore  we can block a thread for an arbitrary amount of time  until a signal from another thread is sent  Semaphores  like the rest of GCD  are thread-safe  and they can be triggered from anywhere  Semaphores can be used when there   s an asynchronous API that you need to make synchronous  but you can   t modify it    Apple Developer API Reference also gives the following discussion for DispatchSemaphore init value    initializer      Passing zero for the value is useful for when two threads need to reconcile the completion of a particular event  Passing a value greater than zero is useful for managing a finite pool of resources  where the pool size is equal to the value    Usage   import Foundation import PlaygroundSupport  PlaygroundPage current needsIndefiniteExecution   true  let queue   DispatchQueue label   com company app queue   attributes   concurrent  let semaphore   DispatchSemaphore value  0   queue async       print   1 started       Thread sleep forTimeInterval  5      print   1 finished       semaphore signal      queue async       print   2 started       Thread sleep forTimeInterval  2      print   2 finished       semaphore signal      queue async       semaphore wait       semaphore wait           print   3 finished          prints    1 started   2 started   2 finished   1 finished   3 finished          6  Using OperationQueue and Operation s addDependency      The Apple Developer API Reference states about Operation Queue      Operation queues use the libdispatch library  also known as Grand Central Dispatch  to initiate the execution of their operations    Usage   import Foundation import PlaygroundSupport  PlaygroundPage current needsIndefiniteExecution   true  let operationQueue   OperationQueue    let blockOne   BlockOperation       print   1 started       Thread sleep forTimeInterval  5      print   1 finished      let blockTwo   BlockOperation       print   2 started       Thread sleep forTimeInterval  2      print   2 finished      let blockThree   BlockOperation       print   3 finished      blockThree addDependency blockOne  blockThree addDependency blockTwo   operationQueue addOperations  blockThree  blockTwo  blockOne   waitUntilFinished  false       prints    1 started   2 started   2 finished   1 finished   3 finished  or   2 started   1 started   2 finished   1 finished   3 finished          7  Using OperationQueue and OperationQueue s addBarrierBlock      requires iOS 13   import Foundation import PlaygroundSupport  PlaygroundPage current needsIndefiniteExecution   true  let operationQueue   OperationQueue    let blockOne   BlockOperation       print   1 started       Thread sleep forTimeInterval  5      print   1 finished      let blockTwo   BlockOperation       print   2 started       Thread sleep forTimeInterval  2      print   2 finished      operationQueue addOperations  blockTwo  blockOne   waitUntilFinished  false  operationQueue addBarrierBlock       print   3 finished          prints    1 started   2 started   2 finished   1 finished   3 finished  or   2 started   1 started   2 finished   1 finished   3 finished

User · Answer

Accepted answer in swift   let group   DispatchGroup    group async group  DispatchQueue global qos   default   execute           block1     print  Block1       Thread sleep forTimeInterval  5 0      print  Block1 End        group async group  DispatchQueue global qos   default   execute           block2     print  Block2       Thread sleep forTimeInterval  8 0      print  Block2 End       dispatch group notify group  DispatchQueue global qos   default            block3     print  Block3          only for non-ARC projects  handled automatically in ARC-enabled projects  dispatch release group

User · Answer

Expanding on J  rn Eyrich answer  upvote his answer if you upvote this one   if you do not have control over the dispatch async calls for your blocks  as might be the case for async completion blocks  you can use the GCD groups using dispatch group enter and dispatch group leave directly   In this example  we re pretending computeInBackground is something we cannot change  imagine it is a delegate callback  NSURLConnection completionHandler  or whatever   and thus we don t have access to the dispatch calls      create a group dispatch group t group   dispatch group create        pair a dispatch group enter for each dispatch group leave dispatch group enter group          pair 1 enter  self computeInBackground 1 completion        NSLog   1 done        dispatch group leave group      pair 1 leave         again     and again     dispatch group enter group          pair 2 enter  self computeInBackground 2 completion        NSLog   2 done        dispatch group leave group      pair 2 leave         Next  setup the code to execute after all the paired enter leave calls        Option 1  Get a notification on a block that will be scheduled on the specified queue  dispatch group notify group  dispatch get global queue DISPATCH QUEUE PRIORITY HIGH  0          NSLog   finally             Option 2  Block an wait for the calls to complete in code already running     as cbartel points out  be careful with running this on the main UI queue          dispatch group wait group  DISPATCH TIME FOREVER      blocks current thread    NSLog   finally       In this example  computeInBackground completion  is implemented as   -  void computeInBackground  int no completion  void     void  block       dispatch async dispatch get global queue DISPATCH QUEUE PRIORITY HIGH  0              NSLog    d starting   no           sleep no 2           block                Output  with timestamps from a run    12 57 02 574  2 starting 12 57 02 574  1 starting 12 57 04 590  1 done 12 57 06 590  2 done 12 57 06 591  finally

User · Answer

Swift 4 2 example   let group   DispatchGroup group count  2  group notify queue  DispatchQueue main         self renderingLine   false         all groups are done   DispatchQueue main async       self renderTargetNode floorPosition  targetPosition  animated  closedContour            group leave              first done           self renderCenterLine position  targetPosition  animated  closedContour            group leave              second done

[ios] Waiting until two async blocks are executed before starting another block

Examples related to ios

Examples related to objective-c

Examples related to objective-c-blocks

Examples related to grand-central-dispatch