在目标c中等效于Java的并发哈希图

Question

I have a NSMuableDictionary accessed by parallel threads,wherein few threads will be enumerating and few threads will be mutating.But we cant achieve this since

"Collections cannot be mutated during enumeration"

.Thought of using NSLock ,but then locking the dictionary till the enumeration completes will result in slow performance.In java we have concurrent hashmap which is smart enough to take care this scenario.Is there any better idea to achieve this in iOS ?.Please help.

Answer 1

Read/Write access to Objective-C containers is generally not thread safe.

You can solve the concurrency problem through associating the container to a dedicated dispatch queue, and then executing ALL read and write accesses on that queue. The queue can be either serial or concurrent.

You can invoke the following methods on any dedicated thread. However, I would suggest to switch your implementation to dispatch lib eventually.

Here, we create a serial queue:

dispatch_queue_t sync_queue = dispatch_queue_create("sync_queue", NULL);

Write access can be made asynchronously:

- (void) addItem:(id)item forKey:(NSString*)key {
    dispatch_async(sync_queue, ^{
        [self.dict setObject:item forKey:key];
    });
}

Read access which returns a value must be synchronous:

- (id) itemForKey:(NSString*)key {
     __block id item;
     dispatch_sync(sync_queue, ^{
         item = [self.dict objectForKey:key];
     });
     return item;
}

You can define similar wrappers for any task:

- (void) iterate {
    dispatch_async(sync_queue, ^{
        for (id item in self.dict) {
            ...
        }
    });
}

---

Using a concurrent queue:

dispatch_queue_t sync_queue = dispatch_queue_create("sync_queue", DISPATCH_QUEUE_CONCURRENT);

Write access can be made asynchronously and needs a barrier:

- (void) addItem:(id)item forKey:(NSString*)key {
    dispatch_barrier_async(sync_queue, ^{
        [self.dict setObject:item forKey:key];
    });
}

Read access which returns a value must be synchronous, and it doesn't need a barrier. Basically, there's no difference for synchronous and concurrent queues:

- (id) itemForKey:(NSString*)key {
     __block id item;
     dispatch_sync(sync_queue, ^{
         item = [self.dict objectForKey:key];
     });
     return item;
}

Answer 2

There is no equivalent in objective-c, but you can avoid errors like "mutated while being enumerated" by holding elements in a temporary Array. See this answer for more info.

Answer 3

EDIT3:

This will do it: Implementing concurrent read exclusive write model with GCD

Might still be some limitations, but at least you will have more fine-grained access and concurrent reads from several threads.

END EDIT 3:

Wrap the access to the dictionary in a class, and use @synchronized(self) {} in the access methods.

EDIT2: Never mind. This will not give you what you want. Left the answer here as an antipattern.

EDIT:

Something like this

(in your object implementation)

- (void) setObjectSynchronized:(id) value forKey:(id) key {
  @synchronized(self) {
     [self.internalDictionary setObject:value forKey:key];
  }
}


- (void) objectForKeySynchronized:(id) key {
  @synchronized(self) {
     return [self.internalDictionary objectForKey:key];
  }
}