@synchronized和dispatch_async

Question

What I'm trying to do is to use the @synchronized directive to protect a singleton object from being accessed by multiple threads at once. I also want to persistently store that singleton object by writing it to disk after each time it's modified, because it is very important that I try as hard as possible not to lose any changes to the object.

Now I know a lot of you might say don't do that; it takes too long; it's not a good practice, etc., etc. Yes, I am aware of that. This is more of a "what will happen?" question.

So whenever I go to modify the singleton object, I put the modification code inside a @synchronized block and then write the object to disk. A thought I had was to use dispatch_async to do the writing of the object on a separate thread like so:

//singleton object
id dataStructure;

@synchronized(lockObject)
    {
        //code that modifies singleton object
        //not important

        //sharedFileQueue is a SERIAL queue
        dispatch_async([self sharedFileQueue], ^(void){
            NSError * err;

            NSData * plist = [NSPropertyListSerialization dataWithPropertyList:dataStructure
                                                      format:NSPropertyListBinaryFormat_v1_0
                                                      options:0 error:&err];

            //url to somewhere
            NSURL * url;
            BOOL success = [plist writeToURL:url atomically:YES];
        });

    }

So my understanding of @synchronized is that only one thread can execute that block of code at a time. My understanding of dispatch_async is a little fuzzy, but I think that this will submit the block to the dispatch queue to be executed asynchronously and return immediately. This means that if another thread comes through my @synchronized block while dataStructure is still being written to disk, it will just submit another block to run and write the newly modified dataStructure to disk, but that won't start until the first dataStructure is written to disk.

Am I thinking about this correctly? Also will setting atomically change to YES or NO or will the serialization of my dispatch queue ensure that multiple threads won't be written to this file at the same time?

Thank you!

Answer 1

https://developer.apple.com/library/ios/documentation/General/Conceptual/ConcurrencyProgrammingGuide/OperationQueues/OperationQueues.html

Dispatch queues themselves are thread safe. In other words, you can submit tasks to a dispatch queue from any thread on the system without first taking a lock or synchronizing access to the queue.

//singleton object
id dataStructure;

@synchronized(lockObject)
{
    //code that modifies singleton object
    //not important

    id dataStructureToWrite = [dataStructure copy];
    //sharedFileQueue is a SERIAL queue
    dispatch_async([self sharedFileQueue], ^(void){
        NSError * err;

        NSData * plist = [NSPropertyListSerialization dataWithPropertyList:dataStructureToWrite
                                                                    format:NSPropertyListBinaryFormat_v1_0
                                                                   options:0 error:&err];

        //url to somewhere
        NSURL * url;
        BOOL success = [plist writeToURL:url atomically:YES];
    });

}

Answer 2

You at least need to synchronise the write on the lock object. This is because the asynchronous block executes outside of the context of the @synchronized{ ... } . This means that something else can change the data while it is being written which can lead to a logical inconsistency.

You probably also want some mechanism to check if the object has been modified since it was last written. Otherwise, you'll find yourself doing unnecessary IO operations. eg

• Thread 1 modifies the object and puts a write on the queue.
• Thread 2 modifies the object and puts a write on the queue.
• Thread 1's write saves the mods from thread 1 and thread 2
• Thread 2's write saves the mods from thread 1 and thread 2 (which is the same as the last step)