Question

I’m playing around with blocks in Objective-C, trying to come up with a reusable mechanism that will take an arbitrary block of code and a lock object and then execute the block of code on a new thread, synchronized on the provided lock. The idea is to come up with a simple way to move all synchronization overhead/waiting off of the main thread so that an app’s UI will always be responsive.

The code I’ve come up with is pretty straightforward, it goes like:

- (void) executeBlock: (void (^)(void))block {
    block();
}

- (void) runAsyncBlock: (void (^)(void))block withLock:(id)lock {
    void(^syncBlock)() = ^{
        @synchronized(lock) {
            block();
        }
    };
    [self performSelectorInBackground:@selector(executeBlock:) withObject:syncBlock];
}

So for example, you might have some methods that go like:

- (void) addObjectToSharedArray:(id) theObj {
    @synchronized(array) {
        [array addObject: theObj];
    }
}

- (void) removeObjectFromSharedArray:(id) theObj {
    @synchronized(array) {
        [array removeObject: theObj];
    }
}

Which works fine, but blocks the calling thread while waiting for the lock. These could be rewritten as:

- (void) addObjectToSharedArray:(id) theObj {
    [self runAsyncBlock:^{
        [array addObject: theObj];
    } withLock: array];
}

- (void) removeObjectFromSharedArray:(id) theObj {
    [self runAsyncBlock: ^{
        [array removeObject: theObj];
    } withLock:array];
}

Which should always return immediately, since only the background threads will compete over the lock.

The problem is, this code crashes after executeBlock: without producing any output, error message, crash log, or any other useful thing. Is there something fundamentally flawed in my approach? If not, any suggestions with respect to why this might be crashing?

Edit:

Interestingly, it works without crashing if I simply do:

- (void) runAsyncBlock: (void (^)(void))block withLock:(id)lock {
    void(^syncBlock)() = ^{
        @synchronized(lock) {
            block();
        }
    };
    syncBlock();
}

But of course this will block the calling thread, which largely defeats the purpose. Is it possible that blocks do not cross thread boundaries? I would think not, since that would largely defeat the purpose of having them in the first place.

Answer 1

remember to call [block copy] otherwise it is not correctly retained because block are created on stack and destroyed when exit scope and unless you call copy it will not move to heap even retain is called.

- (void) runAsyncBlock: (void (^)(void))block withLock:(id)lock {
    block = [[block copy] autorelease];
    void(^syncBlock)() = ^{
        @synchronized(lock) {
            block();
        }
    };
    syncBlock = [[syncBlock copy] autorelease];
    [self performSelectorInBackground:@selector(executeBlock:) withObject:syncBlock];
}