Does dispatch async dispatch get main queue wait until done

Question

I have a scenario in my app  where I want to do some time consuming task which consists of some data processing as well as UI update  in a method  My method looks like this   -  void doCalculationsAndUpdateUIs           DATA PROCESSING 1        UI UPDATE 1         DATA PROCESSING 2        UI UPDATE 2         DATA PROCESSING 3        UI UPDATE 3      As it is time consuming I wanted to do the data processing on the background thread  using   dispatch async dispatch get global queue DISPATCH QUEUE PRIORITY DEFAULT  NULL        But as both data processing and UI updates are in the same method  I wanted to move only the UI updates in main thread using   dispatch async dispatch get main queue         Finally my method looks like this   -  void doCalculationsAndUpdateUIs           DATA PROCESSING 1      dispatch async dispatch get main queue                  UI UPDATE 1                 I expect the control to come here after UI UPDATE 1            DATA PROCESSING 2     dispatch async dispatch get main queue                  UI UPDATE 2                 I expect the control to come here after UI UPDATE 2            DATA PROCESSING 3     dispatch async dispatch get main queue                  UI UPDATE 3             Does this really work  Is this really a good practice  What is the best way to achieve this   P S  All these three operations are interrelated to each other     EDIT  Sorry guys  I have missed a line in the above code  My actual code looks like this   -  void doCalculationsAndUpdateUIs        dispatch async dispatch get global queue DISPATCH QUEUE PRIORITY DEFAULT  0                  DATA PROCESSING 1          dispatch async dispatch get main queue                      UI UPDATE 1                         I expect the control to come here after UI UPDATE 1                DATA PROCESSING 2         dispatch async dispatch get main queue                      UI UPDATE 2                         I expect the control to come here after UI UPDATE 2                DATA PROCESSING 3         dispatch async dispatch get main queue                      UI UPDATE 3                         Once again  I really apologize for the confusion

User · Answer

You have to put your main queue dispatching in the block that runs the computation. For example (here I create a dispatch queue and don't use a global one):

dispatch_queue_t queue = dispatch_queue_create("com.example.MyQueue", NULL);
dispatch_async(queue, ^{
  // Do some computation here.

  // Update UI after computation.
  dispatch_async(dispatch_get_main_queue(), ^{
    // Update the UI on the main thread.
  });
});

Of course, if you create a queue don't forget to dispatch_release if you're targeting an iOS version before 6.0.

User · Answer

OK  there are two ways of doing that      GLOBAL CONCURRENT QUEUE   -  void doCalculationsAndUpdateUIsWith GlobalQUEUE        dispatch queue t globalConcurrentQ   dispatch get global queue DISPATCH QUEUE PRIORITY DEFAULT  0       dispatch async globalConcurrentQ                DATA PROCESSING 1        sleep 1          NSLog   Hello world chekpoint 1           dispatch sync dispatch get main queue                     UI UPDATION 1            sleep 1              NSLog   Hello world chekpoint 2                           the control to come here after UI UPDATION 1            sleep 1           NSLog   Hello world chekpoint 3               DATA PROCESSING 2          dispatch sync dispatch get main queue                      UI UPDATION 2             sleep 1               NSLog   Hello world chekpoint 4                            the control to come here after UI UPDATION 2            sleep 1           NSLog   Hello world chekpoint 5               DATA PROCESSING 3          dispatch sync dispatch get main queue                      UI UPDATION 3             sleep 1               NSLog   Hello world chekpoint 6                               SERIAL QUEUE -  void doCalculationsAndUpdateUIsWith GlobalQUEUE         dispatch queue t serialQ   dispatch queue create  com example MyQueue   NULL       dispatch async serialQ                DATA PROCESSING 1        sleep 1          NSLog   Hello world chekpoint 1            dispatch sync dispatch get main queue                     UI UPDATION 1            sleep 1              NSLog   Hello world chekpoint 2                        sleep 1          NSLog   Hello world chekpoint 3              DATA PROCESSING 2         dispatch sync dispatch get main queue                     UI UPDATION 2            sleep 1              NSLog   Hello world chekpoint 4

User · Answer

dispatch queue t queue   dispatch queue create  com example MyQueue   NULL   dispatch async queue          Do some computation here        Update UI after computation    dispatch async dispatch get main queue              Update the UI on the main thread

User · Answer

Your proposed doCalculationsAndUpdateUIs does data processing and dispatches UI updates to the main queue  I presume that you have dispatched doCalculationsAndUpdateUIs to a background queue when you first called it    While technically fine  that s a little fragile  contingent upon your remembering to dispatch it to the background every time you call it  I would  instead  suggest that you do your dispatch to the background and dispatch back to the main queue from within the same method  as it makes the logic unambiguous and more robust  etc    Thus it might look like   -  void doCalculationsAndUpdateUIs        dispatch async dispatch get global queue DISPATCH QUEUE PRIORITY DEFAULT  NULL                  DATA PROCESSING 1           dispatch async dispatch get main queue                      UI UPDATION 1                         I expect the control to come here after UI UPDATION 1                DATA PROCESSING 2          dispatch async dispatch get main queue                      UI UPDATION 2                         I expect the control to come here after UI UPDATION 2                DATA PROCESSING 3          dispatch async dispatch get main queue                      UI UPDATION 3                         In terms of whether you dispatch your UI updates asynchronously with dispatch async  where the background process will not wait for the UI update  or synchronously with dispatch sync  where it will wait for the UI update   the question is why would you want to do it synchronously  Do you really want to slow down the background process as it waits for the UI update  or would you like the background process to carry on while the UI update takes place    Generally you would dispatch the UI update asynchronously with dispatch async as you ve used in your original question  Yes  there certainly are special circumstances where you need to dispatch code synchronously  e g  you re synchronizing the updates to some class property by performing all updates to it on the main queue   but more often than not  you just dispatch the UI update asynchronously and carry on  Dispatching code synchronously can cause problems  e g  deadlocks  if done sloppily  so my general counsel is that you should probably only dispatch UI updates synchronously if there is some compelling need to do so  otherwise you should design your solution so you can dispatch them asynchronously     In answer to your question as to whether this is the  best way to achieve this   it s hard for us to say without knowing more about the business problem being solved  For example  if you might be calling this doCalculationsAndUpdateUIs multiple times  I might be inclined to use my own serial queue rather than a concurrent global queue  in order to ensure that these don t step over each other  Or if you might need the ability to cancel this doCalculationsAndUpdateUIs when the user dismisses the scene or calls the method again  then I might be inclined to use a operation queue which offers cancelation capabilities  It depends entirely upon what you re trying to achieve   But  in general  the pattern of asynchronously dispatching a complicated task to a background queue and then asynchronously dispatching the UI update back to the main queue is very common

User · Answer

If you want to run a single independent queued operation and you   re not concerned with other concurrent operations  you can use the global concurrent queue  dispatch queue t globalConcurrentQueue   dispatch get global queue DISPATCH QUEUE PRIORITY DEFAULT  0   This will return a concurrent queue with the given priority as outlined in the documentation   DISPATCH QUEUE PRIORITY HIGH Items dispatched to the queue will run at high priority  i e  the queue will be scheduled for execution before any default priority or low priority queue  DISPATCH QUEUE PRIORITY DEFAULT Items dispatched to the queue will run at the default priority  i e  the queue will be scheduled for execution after all high priority queues have been scheduled  but before any low priority queues have been scheduled  DISPATCH QUEUE PRIORITY LOW Items dispatched to the queue will run at low priority  i e  the queue will be scheduled for execution after all default priority and high priority queues have been scheduled  DISPATCH QUEUE PRIORITY BACKGROUND Items dispatched to the queue will run at background priority  i e  the queue will be scheduled for execution after all higher priority queues have been scheduled and the system will run items on this queue on a thread with background status as per setpriority 2   i e  disk I O is throttled and the thread   s scheduling priority is set to lowest value

User · Answer

No it doesn t wait and the way you are doing it in that sample is not good practice   dispatch async is always asynchronous  It s just that you are enqueueing all the UI blocks to the same queue so the different blocks will run in sequence but parallel with your data processing code    If you want the update to wait you can use dispatch sync instead      This will wait to finish dispatch sync dispatch get main queue              Update the UI on the main thread        Another approach would be to nest enqueueing the block  I wouldn t recommend it for multiple levels though    dispatch async dispatch get global queue DISPATCH QUEUE PRIORITY DEFAULT  0             Background work      dispatch async dispatch get main queue                  Update UI          dispatch async dispatch get global queue DISPATCH QUEUE PRIORITY DEFAULT  0                     Background work              dispatch async dispatch get main queue                          Update UI                                           If you need the UI updated to wait then you should use the synchronous versions  It s quite okay to have a background thread wait for the main thread  UI updates should be very quick

User · Answer

The good practice is  Dispatch Groups  dispatch group t imageGroup   dispatch group create     dispatch group enter imageGroup    uploadImage executeWithCompletion   NSURL  result  NSError  error          Image successfully uploaded to S3     dispatch group leave imageGroup        dispatch group enter imageGroup    setImage executeWithCompletion   NSURL  result  NSError  error          Image url updated     dispatch group leave imageGroup        dispatch group notify imageGroup dispatch get main queue             We get here when both tasks are completed

User · Answer

No  it won t wait   You could use performSelectorOnMainThread withObject waitUntilDone

[ios] Does dispatch_async(dispatch_get_main_queue(), ^{...}); wait until done?

Examples related to ios

Examples related to objective-c

Examples related to multithreading

Examples related to grand-central-dispatch

Examples related to dispatch-async