ios - objective - property atomic nonatomic




Was ist der Unterschied zwischen atomaren und nicht atomaren Attributen? (18)

Was bedeuten atomic und nonatomic in Eigenschaftsdeklarationen?

@property(nonatomic, retain) UITextField *userName;
@property(atomic, retain) UITextField *userName;
@property(retain) UITextField *userName;

Was ist der operative Unterschied zwischen diesen drei?


atomar (Standard)

Atomic ist der Standardwert: Wenn Sie nichts eingeben, ist Ihre Eigenschaft atomar. Eine atomare Eigenschaft ist garantiert, dass Sie einen gültigen Wert erhalten, wenn Sie versuchen, von ihr zu lesen. Es gibt keine Garantien dafür, was dieser Wert sein könnte, aber Sie erhalten gute Daten, nicht nur Junk-Speicher. Wenn Sie mehrere Threads oder mehrere Prozesse auf eine einzelne Variable zeigen, kann ein Thread lesen und ein anderer Thread kann schreiben. Bei gleichzeitigem Treffer erhält der Reader-Thread garantiert einen der beiden Werte: entweder vor der Änderung oder nach der Änderung. Was Atomkraft nicht gibt, ist irgendeine Art von Garantie, welche dieser Werte Sie erhalten könnten. Atomic wird häufig mit Threadsafe verwechselt, und das ist nicht korrekt. Sie müssen Ihre Fadensicherheit auf andere Weise garantieren. Allerdings garantiert atomare, dass Sie, wenn Sie versuchen zu lesen, eine Art Wert zurückbekommen.

nichtatomisch

Auf der anderen Seite bedeutet "nicht atomar", wie Sie wahrscheinlich erraten können, einfach "tu das nicht atomares Zeug". Was du verlierst, ist die Garantie, dass du immer etwas zurückbekommst. Wenn Sie versuchen, mitten in einem Schreibvorgang zu lesen, könnten Sie Mülldaten zurück erhalten. Aber auf der anderen Seite, gehen Sie ein bisschen schneller. Da atomare Eigenschaften eine gewisse Magie haben müssen, um zu garantieren, dass Sie einen Wert zurückbekommen, sind sie etwas langsamer. Wenn es sich um eine Eigenschaft handelt, auf die Sie häufig zugreifen, sollten Sie auf "nicht atomisch" wechseln, um sicherzustellen, dass Sie keine Geschwindigkeitsbeschränkung erleiden.

Weitere Informationen finden Sie hier: https://realm.io/news/tmi-objective-c-property-attributes/


Atomic:

Atomic garantiert, dass der Zugang zur Immobilie atomar erfolgt. ZB gibt es immer ein vollständig initialisiertes Objekt zurück, jedes Get / Set einer Eigenschaft in einem Thread muss abgeschlossen sein, bevor ein anderer auf es zugreifen kann.

Wenn Sie sich vorstellen, dass die folgende Funktion auf zwei Threads gleichzeitig auftritt, können Sie sehen, warum die Ergebnisse nicht schön wären.

-(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;
  }

  ...
}

Vorteile: Die Rückgabe von vollständig initialisierten Objekten ist bei Multi-Threading die beste Wahl.

Nachteile: Performance-Hit, macht die Ausführung ein wenig langsamer

Nicht-Atomkraft:

Im Gegensatz zu Atomic stellt es nicht jedes Mal vollständig initialisiertes Objekt zurück.

Vorteile: Extrem schnelle Ausführung.

Nachteile: Wahrscheinlichkeit von Müll im Fall von Multithreading.


Atomic bedeutet, dass nur ein Thread auf die Variable zugreift (statischer Typ). Atomic ist Thread-sicher, aber es ist langsam.

Nichtatomisch bedeutet, dass mehrere Threads auf die Variable zugreifen (dynamischer Typ). Nonatomic ist Thread-unsicher, aber es ist schnell.


Atomic ist Thread-sicher , es ist langsam und es garantiert (nicht garantiert), dass nur der gesperrte Wert zur Verfügung gestellt wird, egal wie viele Threads versuchen, Zugriff über die gleiche Zone. Bei Verwendung von atomar wird ein Code, der innerhalb dieser Funktion geschrieben wird, zum Teil des kritischen Abschnitts, zu dem nur ein Thread gleichzeitig ausgeführt werden kann.

Es gewährleistet nur die Fadensicherheit; das garantiert es nicht. Was ich meine, ist, dass Sie einen erfahrenen Fahrer für Ihr Auto mieten, noch garantiert es nicht, dass Auto keinen Unfall trifft. Die Wahrscheinlichkeit bleibt jedoch gering.

Atomic - es kann nicht abgebaut werden, so wird das Ergebnis erwartet. Bei nichtatomaren - wenn ein anderer Thread auf die Speicherzone zugreift, kann er diese ändern, so dass das Ergebnis unerwartet ist.

Code Diskussion:

Atomic machen Getter und Setter der Eigenschaft Thread sicher. zum Beispiel wenn du geschrieben hast:

self.myProperty = value;

ist fadensicher.

[myArray addObject:@"Abc"] 

ist NICHT threadsicher.


Der beste Weg, um den Unterschied zu verstehen, ist das folgende Beispiel.

Angenommen, es gibt eine atomare String-Eigenschaft namens "name", und wenn Sie [self setName:@"A"] von Thread A aufrufen, rufen Sie [self setName:@"B"] von Thread B auf und rufen [self name] von Thread C, dann werden alle Operationen auf verschiedenen Threads seriell ausgeführt, dh wenn ein Thread einen Setter oder Getter ausführt, warten andere Threads.

Dies macht Eigenschaft "name" les- und schreibsicher, aber wenn ein anderer Thread, D, [name release] gleichzeitig aufruft, könnte dieser Vorgang einen Absturz verursachen, da hier kein Setzer / Getter-Aufruf involviert ist. Dies bedeutet, dass ein Objekt schreibgeschützt (ATOMIC) ist, aber nicht Thread-sicher, da andere Threads gleichzeitig alle Arten von Nachrichten an das Objekt senden können. Der Entwickler sollte die Thread-Sicherheit für solche Objekte sicherstellen.

Wenn die Eigenschaft "name" nichtatomisch ist, werden alle Threads in obigem Beispiel - A, B, C und D - gleichzeitig ausgeführt, was zu unvorhersehbaren Ergebnissen führt. Im Fall von atomaren Systemen wird entweder A, B oder C zuerst ausgeführt, aber D kann immer noch parallel ausgeführt werden.


Die Syntax und Semantik sind bereits durch andere ausgezeichnete Antworten auf diese Frage klar definiert. Weil Ausführung und Leistung nicht genau beschrieben werden, werde ich meine Antwort hinzufügen.

Was ist der funktionelle Unterschied zwischen diesen 3?

Ich hatte atomare Standards immer als ziemlich seltsam betrachtet. Auf der Abstraktionsebene, an der wir arbeiten, ist die Verwendung von atomaren Eigenschaften für eine Klasse als ein Fahrzeug, um 100% Fadensicherheit zu erreichen, ein Eckfall. Für wirklich korrekte Multithread-Programme ist eine Intervention durch den Programmierer fast sicher eine Anforderung. In der Zwischenzeit wurden die Leistungsmerkmale und die Ausführung noch nicht detailliert beschrieben. Nachdem ich im Laufe der Jahre einige Multithread-Programme geschrieben hatte, erklärte ich meine Eigenschaften die ganze Zeit über als nicht atomar, weil Atomwaffen für keinen Zweck sinnvoll waren. Bei der Diskussion der Details der atomaren und nichtatomaren Eigenschaften dieser Frage stieß ich bei einigen Profilierungen auf einige merkwürdige Ergebnisse.

Ausführung

OK. Als erstes möchte ich aufklären, dass die Sperrimplementierung implementierungsdefiniert und abstrahiert ist. Louis verwendet @synchronized(self) in seinem Beispiel - ich habe das als eine gemeinsame Quelle der Verwirrung gesehen. Die Implementierung verwendet nicht tatsächlich @synchronized(self) ; Es verwendet Spin-Locks auf Objektebene. Louis Illustration ist gut für eine High-Level-Illustration mit Konstrukten, die wir alle kennen, aber es ist wichtig zu wissen, dass es @synchronized(self) nicht verwendet.

Ein weiterer Unterschied besteht darin, dass atomare Eigenschaften Ihre Objekte im Getter beibehalten / freigeben.

Performance

Hier ist der interessante Teil: Performance mit atomaren Eigenschaften Zugriffen in unbestätigten (z. B. single-threaded) Fällen kann in einigen Fällen wirklich sehr schnell sein. In weniger als idealen Fällen kann die Verwendung von atomaren Zugriffen mehr als das 20-fache des Overhead von nonatomic . Während der Contreted- Fall mit 7 Threads war 44 Mal langsamer für die Drei-Byte-Struktur (2,2 GHz Core i7 Quad Core, x86_64). Die Drei-Byte-Struktur ist ein Beispiel für eine sehr langsame Eigenschaft.

Interessante Randnotiz: Benutzerdefinierte Accessoren der Drei-Byte-Struktur waren 52-mal schneller als die synthetisierten Atom-Accessoren; oder 84% der Geschwindigkeit von synthetisierten nicht-atomaren Zugriffsmethoden.

Gegenstände in umstrittenen Fällen können auch 50 Mal überschreiten.

Aufgrund der Anzahl von Optimierungen und Variationen in Implementierungen ist es ziemlich schwierig, reale Auswirkungen in diesen Kontexten zu messen. Sie können oft etwas wie "Vertraue es, es sei denn, du profilierst und es ist ein Problem" hören. Aufgrund der Abstraktionsebene ist es tatsächlich ziemlich schwierig, den tatsächlichen Einfluss zu messen. Die tatsächlichen Kosten von Profilen zu berechnen, kann sehr zeitaufwendig und aufgrund von Abstraktionen sehr ungenau sein. ARC vs MRC kann auch einen großen Unterschied machen.

Lassen Sie uns also einen Schritt zurück machen und konzentrieren uns nicht auf die Implementierung von Property-Zugriffen. Wir werden die üblichen Verdächtigen wie objc_msgSend und einige reelle High-Level-Ergebnisse für viele Aufrufe eines NSString Getters in unbestrittenen Fällen untersuchen (Werte in Sekunden):

  • MRC | nichtatomisch | manuell implementierte Getter: 2
  • MRC | nichtatomisch | synthetisierter Getter: 7
  • MRC | Atom | synthetisierter Getter: 47
  • ARC | nichtatomisch | synthetisierter Getter: 38 (Anmerkung: ARC's Ref-Count-Zyklus wird hier hinzugefügt)
  • ARC | Atom | synthetisierter Getter: 47

Wie Sie wahrscheinlich schon vermutet haben, ist die Referenzzählaktivität bzw. der zyklische Zyklus ein signifikanter Faktor bei Atomics und unter ARC. Sie würden auch größere Unterschiede in umstrittenen Fällen sehen.

Obwohl ich sehr auf Leistung achte, sage ich immer noch Semantics First! . In der Zwischenzeit hat die Leistung für viele Projekte eine niedrige Priorität. Das Wissen um Ausführungsdetails und die Kosten von Technologien, die Sie verwenden, ist jedoch nicht schädlich. Sie sollten die richtige Technologie für Ihre Bedürfnisse, Zwecke und Fähigkeiten verwenden. Dies wird Ihnen hoffentlich ein paar Stunden Vergleiche ersparen und Ihnen helfen, eine fundiertere Entscheidung beim Entwerfen Ihrer Programme zu treffen.


Die letzten beiden sind identisch; "atomic" ist das Standardverhalten ( beachten Sie, dass es sich nicht um ein Schlüsselwort handelt; es wird nur durch das Fehlen von nonatomic - atomic wurde in den letzten Versionen von llvm / clang als Schlüsselwort hinzugefügt).

Unter der Annahme, dass Sie die Methodenimplementierungen synthetisieren, ändert der atomare vs. nicht-atomare Code den generierten Code. Wenn Sie Ihre eigenen Setter / Getter schreiben, sind atomare / nichtatomare / behalten / assign / copy nur beratend. (Hinweis: @synthesize ist jetzt das Standardverhalten in den letzten Versionen von LLVM. Es ist auch nicht notwendig, Instanzvariablen zu deklarieren; sie werden auch automatisch synthetisiert und haben einen _ vor ihrem Namen, um einen versehentlichen direkten Zugriff zu verhindern).

Mit "atomisch" stellt der synthetisierte Setter / Getter sicher, dass immer ein ganzer Wert vom Getter zurückgegeben oder vom Setter gesetzt wird, unabhängig von der Setter-Aktivität in einem anderen Thread. Das heißt, wenn sich Thread A in der Mitte des Getters befindet, während Thread B den Setter aufruft, wird ein tatsächlicher realisierbarer Wert - höchstwahrscheinlich ein automatisch wiedergelöschtes Objekt - an den Aufrufer in A zurückgegeben.

Im nonatomic werden solche Garantien nicht nonatomic . nonatomic sind somit wesentlich schneller als "atomare".

Was "Atom" nicht tut, ist Garantie für die Sicherheit der Fäden. Wenn Thread A den Getter gleichzeitig mit Thread B aufruft und C den Setter mit anderen Werten aufruft, kann Thread A irgendeinen der drei zurückgegebenen Werte erhalten - den einen vor dem Aufruf von Setter oder einen der Werte, die an die Setter übergeben wurden in B und C. Ebenso kann das Objekt mit dem Wert von B oder C enden, keine Möglichkeit zu erzählen.

Die Gewährleistung der Datenintegrität - eine der Hauptherausforderungen der Multi-Thread-Programmierung - wird auf andere Weise erreicht.

Hinzu kommt:

atomicity einer einzelnen Eigenschaft kann auch nicht die Threadsicherheit garantieren, wenn mehrere abhängige Eigenschaften im Spiel sind.

Erwägen:

 @property(atomic, copy) NSString *firstName;
 @property(atomic, copy) NSString *lastName;
 @property(readonly, atomic, copy) NSString *fullName;

In diesem Fall könnte Thread A das Objekt setFirstName: indem er setFirstName: und dann setLastName: aufrufen. In der Zwischenzeit kann Thread B fullName zwischen den beiden Aufrufen von Thread A aufrufen und erhält den neuen Vornamen, gekoppelt mit dem alten Nachnamen.

Um dies zu beheben, benötigen Sie ein Transaktionsmodell . Dh eine andere Art von Synchronisation und / oder Ausschluss, die es erlaubt, den Zugriff auf fullName auszuschließen, während die abhängigen Eigenschaften aktualisiert werden.


Dies wird in Apples documentation , aber unten sind einige Beispiele dafür, was tatsächlich passiert. Beachten Sie, dass es kein "atomares" Schlüsselwort gibt, wenn Sie "nichtatomisch" nicht angeben, dann ist die Eigenschaft atomar, aber das explizite Angeben von "atomar" führt zu einem Fehler.

//@property(nonatomic, retain) UITextField *userName;
//Generates roughly

- (UITextField *) userName {
    return userName;
}

- (void) setUserName:(UITextField *)userName_ {
    [userName_ retain];
    [userName release];
    userName = userName_;
}

Die atomare Variante ist jetzt etwas komplizierter:

//@property(retain) UITextField *userName;
//Generates roughly

- (UITextField *) userName {
    UITextField *retval = nil;
    @synchronized(self) {
        retval = [[userName retain] autorelease];
    }
    return retval;
}

- (void) setUserName:(UITextField *)userName_ {
    @synchronized(self) {
      [userName_ retain];
      [userName release];
      userName = userName_;
    }
}

Grundsätzlich muss die atomare Version eine Sperre nehmen, um die Thread-Sicherheit zu garantieren, und auch die ref-Zählung auf dem Objekt (und der Autorelease-Zählung, um es auszugleichen) stoßen, so dass das Objekt garantiert für den Anrufer existiert, ansonsten dort ist eine potentielle Race Condition, wenn ein anderer Thread den Wert setzt, was dazu führt, dass der ref count auf 0 fällt.

Es gibt tatsächlich eine große Anzahl von verschiedenen Varianten, wie diese Dinge funktionieren, abhängig davon, ob die Eigenschaften skalare Werte oder Objekte sind und wie behalten, kopieren, schreibgeschützt, nicht-atomisch usw. interagieren. Im Allgemeinen wissen die Eigenschaftssynthesizer nur, wie man das "Richtige" für alle Kombinationen macht.


Nachdem ich so viele Artikel gelesen, gepostet und Demo-Anwendungen erstellt habe, um Variablenattribute zu überprüfen, habe ich beschlossen, alle Attribute zusammen zu stellen:

  1. atomic // Standard
  2. nonatomic
  3. strong = retain // Standard
  4. weak = unsafe_unretained
  5. retain
  6. assign // Standard
  7. unsafe_unretained
  8. copy
  9. readonly
  10. readwrite // Standard

Im Artikel Variable Eigenschaftenattribute oder Modifizierer in iOS finden Sie alle oben genannten Attribute, und das wird Ihnen definitiv helfen.

  1. atomic

    • atomic bedeutet nur ein Thread Zugriff auf die Variable (statischer Typ).
    • atomic ist threadsicher.
    • Aber es ist langsam in der Leistung
    • atomic ist das Standardverhalten
    • Atomare Zugriffsmethoden in einer Umgebung, in der kein Müll gesammelt wird (dh wenn Retain / Release / Autorelease verwendet wird), verwenden eine Sperre, um sicherzustellen, dass ein anderer Thread die korrekte Einstellung / Ermittlung des Werts nicht beeinträchtigt.
    • Es ist kein Keyword.

    Beispiel:

        @property (retain) NSString *name;
    
        @synthesize name;
    
  2. nonatomic

    • nonatomic bedeutet, dass mehrere Threads auf die Variable zugreifen (dynamischer Typ).
    • nonatomic - nonatomic ist Thread-unsicher.
    • Aber es ist schnell in der Leistung
    • nonatomic ist kein Standardverhalten. Wir müssen das nicht nonatomic Schlüsselwort im Eigenschaftenattribut hinzufügen.
    • Es kann zu unerwartetem Verhalten führen, wenn zwei verschiedene Prozesse (Threads) gleichzeitig auf dieselbe Variable zugreifen.

    Beispiel:

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

Wenn Sie Ihre Eigenschaft in einem Multi-Threaded-Code verwenden, können Sie den Unterschied zwischen nichtatomaren und atomaren Attributen erkennen. Nichtatomare sind schneller als atomare und atomare sind threadsicher, nicht nichtatomare.

Vijayendra Tripathi hat bereits ein Beispiel für eine Multi-Thread-Umgebung gegeben.


Atomic = Fadensicherheit

Nicht atomar = Keine Fadensicherheit

Fadensicherheit:

Instanzvariablen sind Thread-sicher, wenn sie sich korrekt verhalten, wenn sie von mehreren Threads aus aufgerufen werden, unabhängig von der Planung oder Verschachtelung der Ausführung dieser Threads durch die Laufzeitumgebung und ohne zusätzliche Synchronisation oder andere Koordination seitens des aufrufenden Codes.

In unserem Zusammenhang:

Wenn ein Thread den Wert der Instanz ändert, ist der geänderte Wert für alle Threads verfügbar, und nur ein Thread kann den Wert gleichzeitig ändern.

Wo sollte man atomic :

Wenn auf die Instanzvariable in einer Multithread-Umgebung zugegriffen wird.

Implikation von atomic :

Nicht so schnell wie nicht nonatomic da nicht- nonatomic keine nonatomic von der Laufzeit erfordert.

Wo nicht nonatomic zu verwenden nonatomic :

Wenn die Instanzvariable nicht durch mehrere Threads geändert wird, können Sie sie verwenden. Es verbessert die Leistung.



Atomic: Ensure thread-safety by locking the thread using NSLOCK.

Non atomic: Doesn't ensure thread-safety as there is no thread-locking mechanism.


Before discussing about the attributes of @property, you should know what is the use of @property. @property offers a way to define the information that a class is intended to encapsulate. If you declare an object/variable using @property, then that object/variable will be accessible to other classes importing its class. If you declare an object using @property in the header file, then you have to synthesize it using @synthesize in the implementation file.

Beispiel:

.h class

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

.m class

@implementation ExampleClass
   @synthesize name;
@end

Now the compiler will synthesize accessor methods for name.

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

List of attributes of @property : atomic. nonatomic. retain. copy. readonly. readwrite. assign. strong.

atomic : It is the default behaviour. If an object is declared as atomic then it becomes thread-safe. Thread-safe means, at a time only one thread of a particular instance of that class can have the control over that object.

Beispiel:

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

nonatomic: It is not thread-safe. You can use the nonatomic property attribute to specify that synthesized accessors simply set or return a value directly, with no guarantees about what happens if that same value is accessed simultaneously from different threads. For this reason, it's faster to access a nonatomic property than an atomic one. @property (nonatomic)NSString *name;

retain: is required when the attribute is a pointer to an object.The setter method will increase retain count of the object, so that it will occupy memory in autorelease pool. @property (retain)NSString *name;

copy: If you use copy, you can't use retain. Using copy instance of the class will contain its own copy. Even if a mutable string is set and subsequently changed, the instance captures whatever value it has at the time it is set. No setter and getter methods will be synthesized.

@property (copy) NSString *name;

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

readonly: If you don't want to allow the property to be changed via setter method, you can declare the property readonly. @property (readonly) NSString *name;

readwrite: is the default behaviour. You don't need to specify readwrite attribute explicitly.

@property (readwrite) NSString *name;

assign: will generate a setter which assigns the value to the instance variable directly, rather than copying or retaining it. This is best for primitive types like NSInteger and CGFloat, or objects you don't directly own, such as delegates.

@property (assign) NSInteger year;

strong: is a replacement for retain. @property (nonatomic, strong) AVPlayer *player;

unsafe_unretained: There are a few classes in Cocoa and Cocoa Touch that don't yet support weak references, which means you can't declare a weak property or weak local variable to keep track of them. These classes include NSTextView, NSFont and NSColorSpace,etc. If you need to use a weak reference to one of these classes, you must use an unsafe reference. An unsafe reference is similar to a weak reference in that it doesn't keep its related object alive, but it won't be set to nil if the destination object is deallocated.

@property (unsafe_unretained) NSObject *unsafeProperty;


If you are using atomic, it means the thread will be safe and read-only. If you are using nonatomic, it means the multiple threads access the variable and is thread unsafe, but it is executed fast, done a read and write operations; this is a dynamic type.


The atomic property ensures to retain a fully initialised value irrespective of how many threads are doing getter & setter on it.

The nonatomic property specifies that synthesized accessors simply set or return a value directly, with no guarantees about what happens if that same value is accessed simultaneously from different threads.


To simplify the entire confusion let us understand mutex lock.Mutex lock as per the name locks the mutability of the object.So if the object is accessed by a class no other class can access the same object.In iOS @sychronise also provide the mutex lock.Now it serve in FIFO mode and ensures the flow is not affected by two classes sharing the same instance.However if the task is on main thread avoid accessing object using atomic properties as it may hold your UI and degrade the performance


  • -Atomisch bedeutet, dass nur ein Thread auf die Variable zugreift (statischer Typ).
  • -Atomic ist threadsicher.
  • -aber es ist langsam in der Leistung

Wie man erklärt:

Da Atomic standardmäßig ist,

@property (retain) NSString *name;

UND in der Implementierungsdatei

self.name = @"sourov";

Angenommen, eine Aufgabe, die sich auf drei Eigenschaften bezieht, ist

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

Alle Eigenschaften arbeiten parallel (wie asynchron).

Wenn Sie "name" von Thread A aufrufen,

Und

Zur gleichen Zeit, wenn Sie anrufen

[self setName:@"Datta"]

von Thread B ,

Wenn die Eigenschaft * name dann nichtatomisch ist

  • Es wird den Wert "Datta" für A zurückgeben
  • Es wird den Wert "Datta" für B zurückgeben

Das ist der Grund, warum nicht-atomare Threads unsichere genannt werden Aber aber es ist schnell in der Leistung wegen der parallelen Ausführung

Nun, wenn die Eigenschaft * name atomar ist

  • Es wird Wert "Sourov" für A sicherstellen
  • Dann wird der Wert "Datta" für B zurückgegeben

Deshalb nennt man atomic thread Safe und deshalb heißt es read-write safe

Eine solche Situationsoperation wird seriell ausgeführt. Und langsam in der Leistung

- Nichtatomisch bedeutet, dass mehrere Threads auf die Variable (dynamischer Typ) zugreifen.

- Nonatomic ist Thread unsicher.

- Aber es ist schnell in der Leistung

-Nonatomic ist kein Standardverhalten, wir müssen ein nicht atomares Schlüsselwort im Eigenschaftenattribut hinzufügen.

Für In Swift Bestätigung, dass Swift-Eigenschaften im ObjC-Sinne nichtatomisch sind. Ein Grund ist, dass Sie darüber nachdenken, ob die Atomizität pro Objekt für Ihre Bedürfnisse ausreicht.

Referenz: https://forums.developer.apple.com/thread/25642

Für weitere Informationen besuchen Sie bitte die Website http://rdcworld-iphone.blogspot.in/2012/12/variable-property-attributes-or.html







atomic