1

I am building an iOS app which does some heavy lifting on a background thread.

I create my thread using

  dispatch_queue_t backgroundQueue;
  backgroundQueue =  dispatch_queue_create("MyQueue", NULL);

and then put it into GCD using:

   dispatch_async(backgroundQueue, ^
  {

   //some heavy operations here
   //each of them might run for >1 sec

  }

I just want a sequential execution of the queue, provided it doesn't block the main thread. If this block is called from method 3, method 2 and method 1 within 20ms.... they should be necessarily executed in the order 3 -> 2 -> 1, since the output of each method is used up by the next.

I am new to GCD and naively imagined a dispatch queue would use a FIFO queue to execute sequential calls. However, in its current implementation, it is far from sequential.

I tried using NSLock, but they didn't help either.

I would like to know the proper mechanism for enforcing sequential execution in GCD.

EDIT 1:

I am declaring a global queue:

 dispatch_queue_t backgroundQueue ;

and initiating it in viewDidLoad() : 

 backgroundQueue = dispatch_queue_create("MyQueue", DISPATCH_QUEUE_SERIAL);
 //using DISPATCH_QUEUE_SERIAL was a new idea, I also tried using NULL

I'm using GCD to basically call method in another class:

 -(void)doAction()
  {

   dispatch_async(backgroundQueue, ^
        {
                   MyOtherClass *obj = [[MyOtherClass alloc] init];
                   [obj heavyMethod1:  param1 : param2];
                   [obj release];
               });

        }

 -(void)doAnotherAction()
  {

   dispatch_async(backgroundQueue, ^
        {
                   MyOtherClass *obj = [[MyOtherClass alloc] init];
                   [obj heavyMethod2:  param3 : param4];
                   [obj release];
               });

        }

Now, doAction and doAnotherAction method are being called from a number of other methods, depending upon the scenario.

What I'm seeing here is - if I'm calling these methods in the sequence :: doAction -> doAction -> doAnotherAction -> doAction

...I'm getting an output in a sequence like :: doAction -> doAnotherAction -> doAction -> doAction

How do I maintain its sequence of invokation and keep it serial at the same time ?

P.S: - If I remove GCD and allow things to carry on in the main thread, it is theoretically running fine - in simulator. (It crashes in iPhone.)

Improve this question
6
  • How are you passing data from your background queue back to the main queue? Commented May 16, 2013 at 7:29
  • No... writing data to the sandbox... taking it up again from sandbox... all inside GCD, nothing on main queue Commented May 16, 2013 at 7:31
  • Can you post the code that does the saving and loading of data? Commented May 16, 2013 at 7:35
  • 2
    Are you creating a single queue, or do you create on in every method? Commented May 16, 2013 at 8:34
  • edited my question in an attempt to explain things better. please check. Commented May 16, 2013 at 9:36

3 Answers 3

Reset to default
5

There seems to be a lot of confusion in this thread - to try and mitigate that, let me first state some basic facts about GCD:

  1. Serial queues always execute items serially and non-concurrently (with items on the same queue). There is no way to even make GCD "take items from wherever it wants" in a serial queue, so that seems to be some confusion right there.

  2. Concurrent queues can execute blocks submitted to them in any order and on any number of concurrent threads. Unless you are creating a queue as a concurrent queue or using one of the global concurrent queues, you won't get this behavior.

  3. dispatch_async always returns immediately regardless of the type of queue it is posting work to, so it is quite possible to get work interleaved in non-predictable order if you have multiple methods posting work to the same serial queue and those methods are called from multiple places in your code! You have doAction and doAnotherAction methods, for example, but it's not clear where they're being invoked and since each will likely return more or less immediately, you could easily see a doAction/doAction/doAnotherAction chain of submissions.

If the desire is to do multiple things concurrently but each in a predictable order, you should create a serial queue for each "thing" - this is how exclusive access is often maintained (without locks) to critical resources - each resource has its own associated serial queue.

Does that make more sense?

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

Yes, "dispatch_async always returns immediately regardless of the type of queue it is posting work to, so it is quite possible to get work interleaved in non-predictable order if you have multiple methods posting work to the same serial queue and those methods are called from multiple places in your code!" ...was the real problem here. Fixed the bug. The method calls, as indicated in the question, were using up global parameters being posted by multiple method. The parameters were being changed before the call was being fired serially, hence it looked like it was coming in out of serial.
1

The docs provide the following answer:

Serial queues are useful when you want your tasks to execute in a specific order. A serial queue executes only one task at a time and always pulls tasks from the head of the queue. You might use a serial queue instead of a lock to protect a shared resource or mutable data structure. Unlike a lock, a serial queue ensures that tasks are executed in a predictable order.

...

    dispatch_queue_t queue;
    queue = dispatch_queue_create("com.example.MyQueue", NULL);

So you're doing the right thing in principle. You're probably spinning off each block on a separate thread. That won't work, because each separate serial queue will run concurrently. Just submit all the work onto the same queue and you should be golden.

Edit I:

Well, I'm stumped as far as GCD is concerned. Maybe you can try the NSOperation family of classes? You can create NSBlockOperation and add it to an NSOperationQueue, as described in this doc. If you create a second (or third etc.) NSBlockOperation, you can do [anotherBlock addDependency:[yourNSOperationQueue.operations lastObject]] and that should make anotherBlock wait for the operation you last added to yourNSOperationQueue.

For reference (source):

To establish dependencies between two operation objects, you use the addDependency: method of NSOperation. This method creates a one-way dependency from the current operation object to the target operation you specify as a parameter. This dependency means that the current object cannot begin executing until the target object finishes executing.

Improve this answer

10 Comments

I did that. But I don't get anything 'golden'. :) Edited my question to explain the problem better. Please check.
It looks like the property "serial queue executes only one task at a time" is working fine, but the property "always pulls tasks from the head of the queue" is not. It is actually pulling tasks from wherever it wishes to. The suspicion "You're probably spinning off each block on a separate thread." is what I think might be the most probable root cause. Please look at the edited question and respond.
Thanks for the updated question. The plot thickens... You say your app crashes when running on hardware without GCD, but not with GCD?
No crash with GCD. Hardware / simulator, no where. Without GCD, it crashes in h/w only when pushed to the limit. I guess Apple says it is not good to lift heavy stuff in main thread. Watchdog timer kills it, probably. So I resorted to GCD in this case.
Bottom line is, using GCD in this case seems much better an option.
|
1

Your code is correct. Look at example:

dispatch_queue_t backgroundQueue;
backgroundQueue =  dispatch_queue_create("SerialQueue", NULL);

for (int i = 0; i < 10; i++){
    dispatch_async(backgroundQueue, ^{
        int sleepTime = rand()%5;
        sleep(sleepTime);
        NSLog(@"SerialQueue: task %d. sleepTime %d",i,sleepTime);
    });
}

dispatch_queue_t aQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
for (int i = 0; i < 10; i++){
    dispatch_async(aQueue, ^{
        int sleepTime = rand()%5;
        sleep(sleepTime);
        NSLog(@"ConcurrentQueue task %d. sleepTime %d",i,sleepTime);
    });
}

EDIT What are "heavy" methods? Are the synchronous or async? Try such example:

- (void)makeTest{
    [self doActionId: 1];
    [self doActionId: 2];
    [self doAnotherActionId: 3];
    [self doActionId: 4];
}


- (void)doActionId: (NSInteger) id{
    dispatch_async(backgroundQueue, ^{
        int sleepTime = rand()%5;
        sleep(sleepTime);
        NSLog(@"doAction - %d.Sleep time %d", id, sleepTime);
    });
}
- (void)doAnotherActionId:(NSInteger) id{
    dispatch_async(backgroundQueue, ^{
        int sleepTime = rand()%5;
        sleep(sleepTime);
        NSLog(@"doAnotherAction %d. Sleep time %d", id, sleepTime);
    });
}
Improve this answer

1 Comment

The methods were synchronous. DISPATCH_QUEUE_SERIAL was queueing things serially, as expected. I simply goofed up the parameters being passed as argument. If you call 1 -> 2 -> 3 and keep changing global parameters in between, by the time 2 is fired, the parameters will look like they belong to 3. And 2 would have disappeared altogether. This is what happened in my case. Nothing wrong with GCD here.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.