Double @synchronized: is it needed?

Question

I'm developing an iOS application with latest SDK.

My app is a port from an Android application and I have these two methods:

- (MyObject*)getMyObject:(MyObjectType)myObjectType
{
    @synchronized(self)
    {
        for (int index = 0; index < [myObjects count]; index++)
        {
            MyObject* myObject = (MyObject*)[myObjects objectAtIndex:index];
            if (myObject.Type == myObjectType)
                return myObject;
        }

        return nil;
    }
}

- (BOOL)isMyObjectVisible:(MyObjectType)myObjectType
{
    @synchronized(self)
    {
        return ([self getMyObject:myObjectType] != nil);
    }
}

I have isMyObjectVisible:, that is @synchronized, calling another @synchronized method.

Is it necessary that isMyObjectVisible: has to be @synchronized?

Answer 1

To answer your first question, no, the double locking is not needed.

You can keep the lock in getMyObject. That protects it. However, there is nothing in isMyObjectVisible other than a call to getMyObject, so there's nothing else to protect in that method.

However, borrrden's comment is not an issue here. You get a recursive lock when using @synchronized, so you can nest synchronized calls like you're doing without a deadlock. There's just no need to, in your case.