Quelle est la différence entre les attributs atomiques et non atomiques?

après avoir lu tant d'articles, empiler des poteaux de débordement et faire des applications de démonstration pour vérifier les attributs de propriétés variables, j'ai décidé de mettre toutes les informations d'attributs ensemble:

1. atomic // par défaut
2. nonatomic
3. strong = retain // par Défaut
4. weak = unsafe_unretained
5. retain
6. assign // par Défaut
7. unsafe_unretained
8. copy
9. readonly
10. readwrite // par Défaut

dans l'article attributs ou modificateurs de propriété variables dans iOS vous pouvez trouver tous les attributs mentionnés ci-dessus, et qui seront certainement vous aider.

1. atomic

   • atomic désigne un seul thread accédant à la variable (de type statique).
   • atomic est thread-safe.
   • mais il est lent dans la performance
   • atomic est le comportement par défaut
   • accessoires atomiques dans un environnement non collecté lors de l'utilisation de retain/release/autorelease) utilisera une serrure pour s'assurer qu'un autre thread n'interfère pas avec le bon réglage/obtention de la valeur.
   • ce n'est pas vraiment un mot-clé.
     
     
     
     

   exemple:

       @property (retain) NSString *name;
   
       @synthesize name;
   

2. nonatomic

   • nonatomic accès thread multiple à la variable (type dynamique).
   • nonatomic est thread-dangereux.
   • mais il est rapide dans la performance
   • nonatomic n'est pas un comportement par défaut. Nous devons ajouter le mot-clé nonatomic dans l'attribut de propriété.
   • il peut en résulter un comportement inattendu, lorsque deux processus (threads) différents accèdent à la même variable en même temps.
     
     
     
     

   exemple:

       @property (nonatomic, retain) NSString *name;
   
       @synthesize name;
   

la réponse la plus facile d'abord: il n'y a pas de différence entre vos deux exemples. Par défaut, les accesseurs de propriété sont atomiques.

accesseurs atomiques dans un environnement non poubelle (c.-à-d. lors de l'utilisation de conserver/rejeter/autorelease) utilisera une serrure pour s'assurer qu'un autre fil n'interfère pas avec le bon réglage/obtention de la valeur.

voir la" Performance and Threading " section de L'objectif D'Apple - C 2.0 documentation pour plus d'informations et pour d'autres considérations lors de la création d'applications multi-threadées.

Atomique :

atomique garantit que l'accès à la propriété sera effectué de manière atomique. Par exemple: il renvoie toujours un objet entièrement initialisé, tout get / set d'une propriété sur un thread doit être complet avant qu'une autre puisse y accéder.

si vous imaginez la fonction suivante se produire sur deux threads à la fois, vous pouvez voir pourquoi les résultats ne seraient pas joli.

-(void) setName:(NSString*)string
{
  if (name)
  {
    [name release]; 
    // what happens if the second thread jumps in now !?
    // name may be deleted, but our 'name' variable is still set!
    name = nil;
  }

  ...
}

Points forts: Le retour d'objets entièrement initialisés à chaque fois fait le meilleur choix en cas de multi-threading.

Inconvénients : Performance hit, rend l'exécution un peu plus lente

Non-Atomiques:

contrairement à Atomic, il ne garantit pas un retour d'objet entièrement initialisé à chaque fois.

Pour : Exécution extrêmement rapide.

Inconvénients : Les Chances de valeur des déchets en cas de multi-threading.

atomique signifie qu'un seul thread accède à la variable (de type statique). Atomic est sans fil, mais il est lent.

Nonatomique signifie plusieurs threads accédant à la variable (type dynamique). Nonatomic est thread-dangereux, mais il est rapide.

Atomic est thread safe , il est slow et il well-assures (not guaranteed) que seule la valeur verrouillée est fournie peu importe combien de threads tentent d'accéder au-dessus de la même zone. En utilisant atomic, un morceau de code écrit à l'intérieur de cette fonction devient la partie de la section critique, à laquelle seul un thread peut s'exécuter à la fois.

assure seulement la sécurité du fil; il ne garantir que. ce que je veux dire c'est que vous engagez un conducteur expert pour votre voiture, mais cela ne garantit pas que la voiture ne rencontrera pas un accident. Cependant, la probabilité reste la moindre.

atomique-il ne peut pas être décomposé, donc le résultat est attendu. Avec nonatomic-quand un autre thread accède à la zone mémoire, il peut le modifier, de sorte que le résultat est inattendu.

Code De Parler :

Atomique faire des getter et setter de la propriété thread-safe. par exemple si u a écrit:

self.myProperty = value;

est sans fil.

[myArray addObject:@"Abc"] 

n'est pas sans fil.

il n'existe pas de mot-clé "atomique

@property(atomic, retain) UITextField *userName;

nous pouvons utiliser ce qui précède comme

@property(retain) UITextField *userName;

Voir Débordement de Pile question je reçois des questions si j'utilise @property(atomique,conserver)NSString *machaine .

le par défaut est atomic , cela signifie qu'il ne vous coûte la performance chaque fois que vous utilisez la propriété, mais il est thread sûr. Ce que fait Objective-C, est de définir une serrure, de sorte que seul le thread actuel peut accéder à la variable, tant que le setter/getter est exécuté.

exemple avec MRC d'une propriété à usage interne:

[_internal lock]; //lock
id result = [[value retain] autorelease];
[_internal unlock];
return result;

donc ces deux derniers sont les mêmes:

@property(atomic, retain) UITextField *userName;

@property(retain) UITextField *userName; // defaults to atomic

sur l'autre main fait nonatomic n'ajoute rien à votre code. Il n'est donc sûr que si vous codez le mécanisme de sécurité vous-même.

@property(nonatomic, retain) UITextField *userName;

les mots-clés ne doivent pas être écrits en tant que premier attribut de propriété du tout.

N'oubliez pas, cela ne signifie pas que la propriété dans son ensemble est thread-safe. Seul l'appel de méthode du setter/getter est. Mais si vous utilisez un setter et après une lecture à la même fois avec 2 threads différents, il pourrait être cassé aussi!

atomique (par défaut)

Atomique est la valeur par défaut: si vous ne tapez rien, votre propriété est atomique. Une propriété atomique est garantie que si vous essayez de lire à partir c', vous obtiendrez une valeur valide. Il ne donne aucune garantie sur ce que cette valeur pourrait être, mais vous obtiendrez en retour de bonnes données, pas juste ordure de la mémoire. Ce que cela vous permet de le faire est si vous avez plusieurs fils ou processus multiples pointant vers une seule variable, une le fil peut lire et un autre fil peut écrire. S'ils frappent en même temps temps, le fil de lecture est garanti pour obtenir une des deux valeurs: avant le changement ou après le changement. Ce atomique n'a pas vous donner est d'aucune garantie au sujet de laquelle de ces valeurs vous pourriez obtenir. Atomic est vraiment couramment confondu avec étant fil-safe, et ce n'est pas correct. Vous devez garantir la sécurité de votre filetage d'autres moyens. Cependant, atomique sera garantie que si vous essayez de lire, vous obtenez dos une sorte de valeur.

nonatomique

de l'autre côté, non-atomique, comme vous pouvez probablement deviner, signifie Juste, "ne fais pas ça atomique choses."Ce que vous perdez, c'est cette garantie que vous toujours récupérer quelque chose. Si vous essayez de lire au milieu d'un écrire, vous pourriez récupérer des données incorrectes. Mais, d'autre part, vous allez un peu plus vite. Parce que les propriétés atomiques doivent faire un peu de magie pour garantir que vous récupérez une valeur, ils sont un peu plus lent. Si c'est une propriété que vous accédez à un lot, vous pouvez déposer down to nonatomic pour s'assurer que vous n'avez pas cette vitesse pénalité.

voir plus ici: https://realm.io/news/tmi-objective-c-property-attributes /

avant de discuter des attributs de @property, vous devriez savoir à quoi sert @property. @property offre une façon de définir l'information qu'une classe est destinée à encapsuler. Si vous déclarez un objet/variable en utilisant @property, alors cet objet / variable sera accessible aux autres classes qui importent sa classe. Si vous déclarez un objet en utilisant @property dans le fichier d'en-tête, alors vous devez le synthétiser en utilisant @synthize dans le fichier d'implémentation.

exemple:

.classe H

@interface ExampleClass : NSObject
   @property (nonatomic, retain) NSString *name;
@end

.Classe m

@implementation ExampleClass
   @synthesize name;
@end

maintenant le compilateur va synthétiser les méthodes accessor pour le nom.

ExampleClass *newObject=[[ExampleClass alloc]init];
NSString *name1=[newObject name]; // get 'name'
[obj setName:@“Tiger”];

liste des attributs de @property : atomique. nonatomic. conserver. copie. ReadOnly. readwrite. assigner. fort.

atomique : C'est le comportement par défaut. Si un objet est déclaré comme atomique, puis il devient thread-safe. Thread-safe signifie, à la fois, qu'un seul thread d'une instance particulière de cette classe peut avoir le contrôle sur cet objet.

exemple:

@property NSString *name; //by default atomic
@property (atomic)NSString *name; // explicitly declared atomic

nonatomic: Il n'est pas thread-safe. Vous pouvez utiliser l'attribut de propriété non atomique pour spécifier que les accesseurs synthétisés peuvent simplement définir ou retourner une valeur directement, sans aucune garantie sur ce qui se passe si cette même valeur est consultée simultanément à partir de différents threads. Pour cette raison, il est plus rapide pour accéder à une propriété non atomique qu'une propriété atomique. @property (nonatomic)NSString *name;

conserver: est requis lorsque l'attribut est un pointeur vers un objet.La méthode setter augmentera conserver compter de l'objet, de sorte qu'il occupera de la mémoire dans l'autorelease pool. @property (retain)NSString *name;

copie: si vous utilisez la copie, vous ne pouvez pas utiliser la conservation. Utiliser l'instance de copie de la classe contiendra sa propre copie. Même si une chaîne mutable est définie et changée, l'instance capture quelle que soit la valeur qu'elle a au moment où elle est définie. Aucune méthode setter et getter ne sera synthétisée.

@property (copy) NSString *name;

NSMutableString *nameString = [NSMutableString stringWithString:@"Liza"];    
xyzObj.name = nameString;    
[nameString appendString:@"Pizza"];

readonly: si vous ne voulez pas permettre que la propriété soit changée via la méthode setter, vous pouvez déclarer la propriété readonly. @property (readonly) NSString *name;

readwrite: est le comportement par défaut. Vous n'avez pas besoin de spécifier l'attribut readwrite explicitement.

@property (readwrite) NSString *name;

attribuer: va génère un setter qui assigne la valeur à la variable d'instance directement, plutôt que de la copier ou la retenir. C'est mieux pour les types primitifs comme NSInteger et CGFloat, ou les objets que vous ne possédez pas directement, comme les délégués.

@property (assign) NSInteger year;

forts: c'est un remplacement pour le conserver. @property (nonatomic, strong) AVPlayer *player;

unsafe_unretained: il y a quelques classes dans le cacao et le cacao Touch qui ne supportent pas encore les références faibles, qui signifie que vous ne pouvez pas déclarer une propriété faible ou une variable locale faible pour garder une trace d'eux. Ces classes comprennent Ntextview, NSFont et NSColorSpace,etc. Si vous avez besoin d'utiliser une faible référence à l'une de ces classes, vous devez utiliser un dangereux référence. Une référence non sécuritaire est similaire à une référence faible en ce sens qu'elle ne garde pas son objet apparenté vivant, mais elle ne sera pas réglée à zéro si l'objet destination est désallocé.

@property (unsafe_unretained) NSObject *unsafeProperty;

si vous utilisez votre propriété en code multi-threadé, vous pourrez voir la différence entre les attributs non atomiques et atomiques. Le nonatomique est plus rapide que l'atomique et l'atomique est sans fil, pas le nonatomique.

Vijayendra Tripathi a déjà donné un exemple pour un environnement multi-threadé.

• -Atomic signifie un seul thread accédant à la variable(type statique).
• -Atomique est thread-safe.
• - mais il est lent dans la performance

comment déclarer:

Comme atomique est valeur par défaut donc,

@property (retain) NSString *name;

et dans le fichier de mise en œuvre

self.name = @"sourov";

supposons qu'une tâche liée à trois propriétés soit

 @property (retain) NSString *name;
 @property (retain) NSString *A;
 @property (retain) NSString *B;
 self.name = @"sourov";

toutes les propriétés fonctionnent en parallèle (comme asynchrone).

si vous appelez "nom" à partir du fil A ,

et

En même temps, si vous appelez

[self setName:@"Datta"]

à partir de fils B ,

Maintenant, Si *le nom de la propriété est nonatomic puis

• Il sera de retour la valeur "Datta" pour Un
• il retournera la valeur "Datta" pour B

"C'est pourquoi Non atomique est appelé thread dangereux, mais mais il est rapide dans la performance en raison de l'exécution parallèle

Maintenant, Si *le nom de la propriété est atomique

• Elle permettra de s'assurer de la valeur "Sourov" pour Un
• puis il retournera la valeur "Datta" pour B

c'est pourquoi atomic est appelé sans fil et C'est pour ça qu'on l'appelle read-write safe

une telle opération de situation se déroulera en série. Et Lent en performance

- Nonatomic-à-dire plusieurs thread accéder à la variable(de type dynamique).

- Nonatomic est thread dangereux.

- mais il est rapide dans la performance

-Nonatomic n'est PAS le comportement par défaut, nous avons besoin d'ajouter nonatomic mot-clé dans la propriété de l'attribut.

Pour En Swift Confirmant que les propriétés de Swift sont non atomiques au sens D'ObjC. Une raison est donc vous pensez à savoir si l'atomicité par propriété est suffisante pour vos besoins.

référence: https://forums.developer.apple.com/thread/25642

Fro plus d'informations s'il vous plaît visitez le site web http://rdcworld-iphone.blogspot.in/2012/12/variable-property-attributes-or.html

avant de commencer: vous devez savoir que chaque objet dans la mémoire doit être retiré de la mémoire pour qu'une nouvelle écriture se produise. Vous ne pouvez pas simplement écrire sur quelque chose comme vous le faites sur le papier. Vous doit d'abord l'effacer (dealloc) et ensuite vous pouvez écrire dessus. Si au moment où l'effacement est fait (ou la moitié fait) et rien a encore a été écrit (ou la moitié a écrit) et vous essayez de lire il pourrait être très problématique! Atomiques et non atomiques vous aider à traiter ce problème de différentes manières.

lire D'abord cette" question puis lire réponse de Bbum . En outre, puis lire mon résumé.

---

atomic garantira toujours

• si deux personnes différentes veulent lire et écrire en même temps, votre papier ne brûlera pas! --> Votre demande ne jamais s'écraser, même dans un État de course.
• si une personne essaie d'écrire et n'a écrit que 4 des 8 lettres à written, alors aucune ne peut lire au milieu, la lecture ne peut être faite que lorsque les 8 lettres sont écrites --> aucune lecture(get) n'aura lieu sur 'un thread qui est encore en train d'écrire', c.-à-d. s'il y a 8 bytes aux bytes à écrire, et seulement 4 bytes sont écrits--jusqu'à ce moment, vous n'êtes pas autorisé à lire à partir de celui-ci. Mais comme j'ai dit qu'il ne s'écraserait pas alors il lirait de la valeur d'un objet autoreleased .
• si avant vous écrivant ont effacé ce qui a été précédemment écrit sur le papier et alors quelqu'un veut vous lire can encore lire. Comment? Vous lirez à partir de quelque chose de similaire à Mac OS poubelle (comme poubelle N'est pas encore 100% effacé...il est dans un limbo) - - - > si ThreadA est à lire alors que ThreadB a déjà été attribué à write, vous pouvez soit obtenir la valeur de la valeur finale entièrement écrite par ThreadB ou obtenir quelque chose de autorelease pool.

Conserver les comptes sont la façon dont la mémoire est gérée en Objective-C. Lorsque vous créez un objet, il a conserver un nombre de 1. Lorsque vous envoyez un objet conserver un message, conserver son compteur est incrémenté de 1. Lorsque vous envoyez un objet, un message de libération, conserver son compteur est décrémenté par 1. Lorsque vous envoyez un l'objet d'une autorelease message , ses conserver le comte est décrémenté de 1 à un certain moment dans l'avenir. Si un object's conserver nombre est réduit à 0, il est libéré.

• Atomic doesn't garantir la sécurité du fil, bien que son utile pour atteindre la sécurité du fil. La sécurité du fil est relative à la façon dont vous écrivez votre code/ quelle file d'attente de fil vous lisez/écrivez. Il garantit seulement non-crashable multithreading.

---

attendre quoi?! Est-ce que multithreading et thread safety sont différents?

Oui. Multithreading signifie: plusieurs threads peuvent lire un morceau de données partagées en même temps et nous ne nous écraserons pas, mais cela ne garantit pas que vous ne lisez pas à partir d'une valeur non autoreleased. Avec la sécurité de fil, il est garanti que ce que vous lisez n'est pas auto-relâché. La raison pour laquelle nous ne faisons pas tout atomique par défaut est, parce qu'il ya un coût de performance et pour la plupart des choses n'ont pas vraiment besoin de la sécurité du fil. Quelques parties de notre code en ont besoin et pour ces quelques parties nous avons besoin d'écrire notre code d'une manière sûre en utilisant des serrures, du mutex ou de la synchronisation.

---

nonatomic

• Puisqu'il n'y a pas de poubelle Mac OS, alors personne ne se soucie de savoir si oui ou non vous obtenez toujours une valeur (<-- cela pourrait potentiellement conduire à un crash), ni personne ne se soucie si quelqu'un essaie de lire à mi-chemin à travers vous en écrivant (bien que l'écriture à mi-chemin dans la mémoire est très différente de l'écriture à mi-chemin sur le papier, sur la mémoire il pourrait vous donner une valeur stupide folle d'avant, tandis que sur le papier vous ne voyez que la moitié de ce qui a été écrit) --> ne garantit pas de ne pas crash, parce qu'il n'utilise pas de mécanisme autorelease.
• N'est pas garantie des valeurs écrites complètes à lire!
• est plus rapide qu'atomique

---

dans l'ensemble, ils sont différents en deux points:

• S'écraser ou non à cause d'avoir ou de ne pas avoir autorelease pool.

• permettant d'être lu en plein milieu d'une "écriture pas encore terminée ou valeur vide" ou ne permettant pas et seulement permettant de lire lorsque la valeur est entièrement écrit.

la propriété atomique garantit de conserver une valeur entièrement initialisée indépendamment du nombre de threads qui y font getter & setter.

la propriété nonatomique spécifie que les accesseurs synthétisés ne font que définir ou retourner une valeur directement, sans aucune garantie sur ce qui se passe si cette même valeur est accessible simultanément à partir de différents threads.

Atomique signifie qu'un seul thread peut accéder à la variable à la fois (de type statique). Atomic est sans fil, mais il est lent.

Nonatomique signifie que plusieurs threads peuvent accéder à la variable en même temps (type dynamique). Nonatomic est thread-dangereux, mais il est rapide.

si vous utilisez atomic, cela signifie que le fil sera sûr et en lecture seule. Si vous utilisez nonatomic, cela signifie que les threads multiples accèdent à la variable et est thread dangereux, mais il est exécuté rapidement, fait une lecture et des opérations d'écriture; c'est un type dynamique.

Atomic: assurer la sécurité du thread en verrouillant le thread à l'aide de NSLOCK.

Non atomique: ne garantit pas la sécurité du thread car il n'y a pas de mécanisme de verrouillage du thread.

pour simplifier toute la confusion laissez-nous comprendre serrure mutex.Mutex lock comme par le nom des verrous de la mutabilité de l'objet.Donc, si l'objet est accessible par une classe d'aucune autre classe peuvent accéder au même objet.Dans iOS @sychronise également fournir le mutex lock.Maintenant il sert en mode FIFO et assure que le flux n'est pas affecté par deux classes partageant la même instance.Cependant, si la tâche est sur le thread principal, évitez d'accéder à l'objet en utilisant des propriétés atomiques car il peut contenir votre UI et dégrader le performance

la vérité est qu'ils utilisent spin lock pour mettre en œuvre la propriété atomique. Le code suivant:

 static inline void reallySetProperty(id self, SEL _cmd, id newValue, 
      ptrdiff_t offset, bool atomic, bool copy, bool mutableCopy) 
    {
        id oldValue;
        id *slot = (id*) ((char*)self + offset);

        if (copy) {
            newValue = [newValue copyWithZone:NULL];
        } else if (mutableCopy) {
            newValue = [newValue mutableCopyWithZone:NULL];
        } else {
            if (*slot == newValue) return;
            newValue = objc_retain(newValue);
        }

        if (!atomic) {
            oldValue = *slot;
            *slot = newValue;
        } else {
            spin_lock_t *slotlock = &PropertyLocks[GOODHASH(slot)];
            _spin_lock(slotlock);
            oldValue = *slot;
            *slot = newValue;        
            _spin_unlock(slotlock);
        }

        objc_release(oldValue);
    }

propriétés Atomiques :- Lorsqu'une variable est assignée propriété de l'atome qui signifie qu'il n'a qu'un seul thread d'accès et il va être thread-safe et sera bien en vue des performances, aura le comportement par défaut.

Non Propriétés Atomiques :- Lorsqu'une variable est assignée propriété de l'atome qui signifie qu'il a multi thread d'accès et il ne sera pas thread-safe et sera lente au point de vue des performances, aura comportement par défaut et lorsque deux threads différents veulent accéder à la variable en même temps, il donnera des résultats inattendus.