NSMutableDictionary fil de sécurité

J'ai une question sur le thread de sécurité lors de l'utilisation NSMutableDictionary.

Le thread principal est la lecture des données à partir de NSMutableDictionary où:

  • clé est NSString
  • valeur est UIImage

Un thread asynchrone est de l'écriture des données ci-dessus dictionnaire (à l'aide de NSOperationQueue)

Comment je fais les au-dessus de dictionnaire thread-safe?

Devrais-je faire la NSMutableDictionary propriété atomic? Ou ai-je besoin d'apporter des modifications supplémentaires?

@property(retain) NSMutableDictionary *dicNamesWithPhotos;

  • Je ne suis pas expert sur le multithreading, mais je sais que le "atomique" drapeau (la valeur par défaut pour @synthétiser avais accesseurs) ne donne aucune garantie de la sécurité des threads. J'ai pensé la même chose quand j'ai lu à ce sujet, cependant.
InformationsquelleAutor Raj | 2009-12-31
  1. 73

    NSMutableDictionary n'est pas conçu pour être thread-safe structure de données, et de simplement marquer la propriété atomic, ne garantit pas que les données sous-jacentes des opérations s'effectue automatiquement (de manière sécurisée).

    Pour s'assurer que chaque opération est faite de façon sécuritaire, vous auriez besoin de garde de chaque opération sur le dictionnaire avec une serrure:

    //in initialization
self.dictionary = [[NSMutableDictionary alloc] init];
//create a lock object for the dictionary
self.dictionary_lock = [[NSLock alloc] init];


//at every access or modification:
[object.dictionary_lock lock];
[object.dictionary setObject:image forKey:name];
[object.dictionary_lock unlock];

    Vous devriez envisager de déployer votre propre NSDictionary que, tout simplement, les délégués des appels à NSMutableDictionary tout en maintenant un verrou:

    @interface SafeMutableDictionary : NSMutableDictionary
{
    NSLock *lock;
    NSMutableDictionary *underlyingDictionary;
}

@end

@implementation SafeMutableDictionary

- (id)init
{
    if (self = [super init]) {
        lock = [[NSLock alloc] init];
        underlyingDictionary = [[NSMutableDictionary alloc] init];
    }
    return self;
}

- (void) dealloc
{
   [lock_ release];
   [underlyingDictionary release];
   [super dealloc];
}

//forward all the calls with the lock held
- (retval_t) forward: (SEL) sel : (arglist_t) args
{
    [lock lock];
    @try {
        return [underlyingDictionary performv:sel : args];
    }
    @finally {
        [lock unlock];
    }
}

@end

    Veuillez noter que parce que chaque opération nécessite d'attente pour le verrouiller et de le tenir, il n'est pas évolutive, mais il pourrait être assez bon dans votre cas.

    Si vous souhaitez utiliser un bon filetée de la bibliothèque, vous pouvez utiliser TransactionKit bibliothèque comme ils l'ont TKMutableDictionary qui est un multi-thread safe bibliothèque. Personnellement, je ne l'ai pas utilisé, et il semble que c'est un travail en cours de la bibliothèque, mais vous pourriez vouloir donner un essai.

    • Cela ressemble à une bonne méthode mais je n'arrive pas à compiler. Je suis "expected ')' before 'retval_t'" sur la ligne - (retval_t) forward: (SEL) sel : (arglist_t) args des idées?
    • Fabuleux réponse. Maintenant obsolète. Utiliser une file d'attente à la place. J'ai un simple morts sérialisé dictionnaire quelque part. Je devrais le poster. Le transfert des messages est lente et fragile.
    • Suivi de bbum commentaire. Il est utile d'écrire-up sur l'utilisation de PGCD simultanées de files d'attente avec NSMutableDictionary sur Mike Cendres du blog ici: mikeash.com/pyblog/friday-qa-2011-10-14-whats-new-in-gcd.html
    • avez-vous toujours gérer pour afficher un exemple de votre sérialisés dictionnaire?
    • Comment au sujet de l'utilisation de @sychronized pour le rendre sûr?
    • Je suis d'accord avec @AllenLin commentaire, je trouve @synchronized d'être plus pratique que d'essayer explicitement de verrouillage/déverrouillage.
    • D'accord avec @allenlinli, c'est essentiellement ce qui @synchronized fait pour vous sans frais puisque nous sommes juste verrouillage de l'accès au dictionnaire et de ne pas discerner si c'est un get/set opération.

    InformationsquelleAutor notnoop
  2. 1

    après un peu de recherche, j'ai envie de partager avec vous cet article :

    À l'aide de classes de collection en toute sécurité avec les applications multithread
    http://developer.apple.com/library/mac/#technotes/tn2002/tn2059.html

    Il ressemble notnoop la réponse peut ne pas être une solution, après tout. De filetage perspective, il est ok, mais il y a certaines subtilités. Je ne vais pas poster ici une solution mais je pense qu'il y a un bon dans cet article.

    • +1 pour remarquer que le verrouillage n'est pas suffisant dans ce cas. J'ai été mordu par cette fois, ainsi, les [[[dict objectForKey:key] retain] autorelease] "truc" est vraiment nécessaire dans un environnement multithread.
    • Que le lien est rompu, et la note technique est à partir de 2002. Vous pourriez être mieux avec developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/....
    • -1 Pour ce qui est presque (mais pas tout à fait, évitant ainsi de repérage, un lien unique réponse.
    InformationsquelleAutor Adrian
  3. 1

    J'ai deux options à l'aide de nsmutabledictionary.

    Est:

    NSLock* lock = [[NSLock alloc] init];
[lock lock];
[object.dictionary setObject:image forKey:name];
[lock unlock];

    Deux:

    //Let's assume var image, name are setup properly
dispatch_async(dispatch_get_main_queue(), 
^{ 
        [object.dictionary setObject:image forKey:name];
});

    Je ne sais pas pourquoi certaines personnes veulent écraser le réglage et l'obtention de mutabledictionary.

    InformationsquelleAutor gigir
  4. 1

    Même la réponse est correcte, il est un élégant et autre solution:

    - (id)init {
self = [super init];
if (self != nil) {
    NSString *label = [NSString stringWithFormat:@"%@.isolation.%p", [self class], self];
    self.isolationQueue = dispatch_queue_create([label UTF8String], NULL);

    label = [NSString stringWithFormat:@"%@.work.%p", [self class], self];
    self.workQueue = dispatch_queue_create([label UTF8String], NULL);
}
return self;
}
//Setter, write into NSMutableDictionary
- (void)setCount:(NSUInteger)count forKey:(NSString *)key {
key = [key copy];
dispatch_async(self.isolationQueue, ^(){
    if (count == 0) {
        [self.counts removeObjectForKey:key];
    } else {
        self.counts[key] = @(count);
    }
});
}
//Getter, read from NSMutableDictionary
- (NSUInteger)countForKey:(NSString *)key {
__block NSUInteger count;
dispatch_sync(self.isolationQueue, ^(){
    NSNumber *n = self.counts[key];
    count = [n unsignedIntegerValue];
});
return count;
}

    La copie est important lors de l'utilisation de thread objets dangereux, avec ce que vous pourriez éviter l'erreur possible en raison de la dissémination involontaire de la variable. Pas besoin de thread-safe entités.

    Si plus de file d'attente voudrais utiliser la NSMutableDictionary déclarer une file d'attente privée et modifier le setter pour:

    self.isolationQueue = dispatch_queue_create([label UTF8String], DISPATCH_QUEUE_CONCURRENT);

- (void)setCount:(NSUInteger)count forKey:(NSString *)key {
key = [key copy];
dispatch_barrier_async(self.isolationQueue, ^(){
    if (count == 0) {
        [self.counts removeObjectForKey:key];
    } else {
        self.counts[key] = @(count);
    }
});
}

    IMPORTANT!

    Vous devez définir une file d'attente privée, sans elle, l' dispatch_barrier_sync est juste un simple dispatch_sync

    Explication détaillée est dans ce merveilleux article du blog.

    InformationsquelleAutor BootMaker
  5. 1

    Aujourd'hui tu serais probablement aller pour @synchronized(object) à la place.

    ...
@synchronized(dictionary) {
    [dictionary setObject:image forKey:name];
}
...
@synchronized(dictionary) {
    [dictionary objectForKey:key];
}
...
@synchronized(dictionary) {
    [dictionary removeObjectForKey:key];
}

    Pas besoin de la NSLock objet plus

    InformationsquelleAutor P.Melch