Question

I have an Objective-C class whose instances can detect when they are no longer needed and destroy themselves, but I am looking for a safe way to trigger an object’s self-destruction from within the object itself, without somehow “destroying the method that is calling the destruction”… My code looks roughly like this (some removed for brevity):

+ (oneway void)destroyInstance:(id)obj {

    printf("Destroying.\n");
    if (obj != nil) {
        free(obj);
        obj = nil;
    }

}

- (oneway void)release {

    _noLongerRequired = [self determineIfNeeded]; // BOOL retVal

    if (_noLongerRequired) {
        [self deallocateMemory]; // Free ivars etc (NOT oneway)
        [MyClass destroyInstance:self]; // Oneway
    }
}

If I call -release, it should return instantly to the main thread (due to the oneway).

Meanwhile, if the instance finds it is no longer needed, it should then call the oneway class method destroyInstance: and remove itself from the runtime. My question is, is this safe?? And have I used oneway correctly? It seems to me there is the possibility of destroying the instance’s -release function before it returns, which could be… rather bad..?

(PS: Obviously not looking for anything to do with NSObject, etc :))

Answer 1

This is without a doubt a terrible idea if you want working and maintainable software and unsafe in just about any context. But sometimes terrible, unsafe ideas can be fun on the weekend, so I’ll answer the components of the question I can discern.

A method will not get “destroyed” because an instance is deallocated. What can happen is that self can end up pointing to deallocated memory during the execution of a method, which means that accessing self or any instance variables during this time can crash.

As to the rest of your code, there is no reason at all to set obj equal to nil in +destroyInstance, so if you were trying accomplish something in particular (nil‘ing out pointers to the object perhaps) that way is not the right way to go about it.

Thinking about the use of oneway, what the language says is that sending this message won’t block the calling thread. In the context of releasing objects I think it makes some sense, as presumably the target of the message won’t ever be referenced by that thread again. By that logic I’d think your declaration of +destroyInstance is maybe OK. I do wonder if you’d need to provide some sort of synchronization so that there’s no retain/release race conditions but thinking about it, taking ownership of an object should probably never be asynchronous.

My personal opinion is that anyone who puts this code into production should probably be fired or sued =P. But if it’s only for educational purposes, have fun, and hope this helps.