GCD : How to write and read to variable from two threads

Question

this may sound a newbie question anyway Im new to GCD,

I'm creating and running these two following threads. The first one puts data into ivar mMutableArray and the second one reads from it. How do i lock and unclock the threads to avoid crashes and keep the code thread safe ?

// Thread for writing data into mutable array 
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
if (timer) {
    dispatch_source_set_timer(timer, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC * interval), interval * NSEC_PER_SEC, leeway);
    dispatch_source_set_event_handler(timer, ^{
        ...
        // Put data into ivar
        [mMutableArray addObject:someObject];
        ...
    });
    dispatch_resume(timer);
}

// Thread for reading from mutable array
dispatch_source_t timer1 = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
if (timer1) {
    dispatch_source_set_timer(timer1, dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC * interval), interval * NSEC_PER_SEC, leeway);
    dispatch_source_set_event_handler(timer1, ^{
        ...
        if (mMutableArray) {
            // Read data from ivar
            SomeObject* someobject = [mMutableArray lastObject];
        }
        ...
    });
    dispatch_resume(timer1);
}

Answer 1

You can still use @synchronized on your critical sections with GCD

Answer 2

You are using it wrong, by locking access to the variables you are simply losing any benefit from GCD. Create a single serial queue which is associated to the variables you want to modify (in this case the mutable array). Then use that queue to both write and read to it, which will happen in guaranteed serial sequence and with minimum locking overhead. You can read more about it in "Asynchronous setters" at http://www.fieryrobot.com/blog/2010/09/01/synchronization-using-grand-central-dispatch/. As long as your access to the shared variable happens through its associated dispatch queue, you won't have concurrency problems ever.

Answer 3

I've used mutexes in my project and I'm quite happy with how it works at the moment.

Create the mutex and initialise it

pthread_mutex_t *mutexLock;
pthread_mutex_init(&_mutex, NULL);

Then put the lock around your code, once the second thread tries to get the lock, it will wait until the lock is freed again by the first thread. Note that you still might want to check if the first thread is actually the one writing to it.

pthread_mutex_lock(self_mutex);
{
    ** Code here
}
pthread_mutex_unlock(self_mutex);