在Objective-c中，如何确保一个代码在另一个代码之后被调用？

Question

I don't mean synchronize and stuff. This is not in general good programming practice actually. I just think that there is something that should be done.

For example, say I have a thread that will suspend it self and wait till an event occur. Often the event occur before that thread suspend itself.

So I want the event to wait till the thread suspend itself before it occurs.

How do I do that?

For example, say I want to do 5 things on mainQueue.

Do something. Wait till it's finished, do next.

I do this then:

-(void) vDoSomeStuffsInSequence:(NSArray *) arblArrayOfBlocksToExecuteOnMainThread
{
    if (self.blockThis) {
        PO(@"Cancel Push View Controller");
        return;
    }
    @synchronized(self)
    {
        self.blockThis=true;
    }
    AssertMainThread

    NSMutableArray * arblNotFirstBlocks = [arblArrayOfBlocksToExecuteOnMainThread mutableCopy];

    void(^blockToExecute)() = arblNotFirstBlocks[0];//execute first block right away
    blockToExecute();
    PO(@"execute pop push etc");
    [arblNotFirstBlocks removeObjectAtIndex:0];


    [[NSOperationQueue new] addOperationWithBlock:^{
        PO(@"before first suspend");
        [self vSuspendAndHaltThisThreadTillUnsuspended]; //This often happen after (instead of before) the code that execute [self vContinue is called]
        PO(@"after first suspend");
        for (void(^blockToExecute)() in arblNotFirstBlocks) {

            while(false);
            [[NSOperationQueue mainQueue] addOperationWithBlock:^{
                blockToExecute();//dothisfirst must unsuspend a thread somewhere
            }];

            [self vSuspendAndHaltThisThreadTillUnsuspended];
        }
        [[NSOperationQueue mainQueue]addOperationWithBlock:^{
            @synchronized(self)
            {
                self.blockThis=false;
            }
            [self vContinue];
        }];
        [self vSuspendAndHaltThisThreadTillUnsuspended];
        PO(@"finish vDoSomeStuffsInSequence");
    }];
}

Answer 1

What you are describing is a well-known race condition that arises in many event-delivery systems, and the solution depends on the details of the system's programming interface.

For example, detecting a Unix signal is prone to this race condition, and there are a number of solutions (of varying portability). See “Handling Signals” on the Event Loop Wikipedia page for a couple of them.

So the answer to your question depends entirely on what events you want to detect and the programming interfaces available to detect them. You need to edit your post to include those details if you want a more specific answer.

Answer 2

Polling, waiting, and long or indefinite thread or resource blocking are generally best avoided. Nevertheless... you can wait using condition variables, dispatch_group_wait , or -[NSOperationQueue waitUntilAllOperationsAreFinished] .