Was atomicund nonatomicin Eigenschaftsdeklarationen bedeuten?
@property(nonatomic, retain) UITextField *userName;
@property(atomic, retain) UITextField *userName;
@property(retain) UITextField *userName;
Was ist der operative Unterschied zwischen diesen drei?
Die letzten beiden sind identisch; „atomare“ ist das Standardverhalten ( beachten Sie, dass es nicht wirklich ein Schlüsselwort ist, sondern nur durch das Fehlen angegeben ist - nonatomicatomicwurde als Schlüsselwort in der letzten Versionen von llvm / Klirren hinzugefügt).
Unter der Annahme , dass Sie die Methode Implementierungen @synthesizing, Atom vs. nicht-atomaren Änderungen der generierte Code. Wenn Sie Ihren eigenen Setter / Getter schreiben, Atom / nonatomic / behalten / assign / copy sind lediglich beratenden Charakter haben . (Hinweis: @synthesize ist jetzt das Standardverhalten in der letzten Versionen von LLVM Es gibt auch keine Notwendigkeit , Instanzvariablen zu erklären, werden sie automatisch synthetisiert werden, auch, und haben ein. _Vorangestellt ihre Namen versehentlichen direkten Zugriff zu verhindern).
Mit „atomic“, wird die synthetisierte setter / Getter sicherzustellen , dass ein gesamte Wert immer aus dem Getter oder eingestellt durch die setter zurückgeführt wird, unabhängig von setter Aktivität auf einem anderen Thread. Das heißt, wenn Thread A in der Mitte des Getter ist , während Thread B die Setter nennt, ein tatsächlicher tragfähige Wert - ein Autoreleased Objekt, höchstwahrscheinlich - wird den Anrufer in A. zurückgegeben werden
In nonatomicwerden keine solche Garantien. Somit nonatomicist wesentlich schneller als „atomaren“.
Was „atomic“ ist nicht tun , ist keine Garantien über die Thread - Sicherheit machen. Wenn Thread A wird das Getter gleichzeitig mit Gewinde B anruft und C der Setter mit unterschiedlichen Werten nennen, kann Thread A erhalten eine der drei Werte zurückgeführt - die eine vor irgendwelchen setters aufgerufen wird oder eine der beiden Werte in die Einrichter weitergegeben Ebenso in B und C kann das Objekt mit dem Wert von B oder C enden, zu sagen , auf keinen Fall.
Die Sicherstellung der Datenintegrität - eine der primären Herausforderungen der Programmierung Multi-Threaded - wird durch andere Mittel erreicht.
Rechnet man dazu:
atomicity auch von einer einzigen Eigenschaft kann nicht Thread-Sicherheit, wenn mehrere abhängigen Eigenschaften sind im Spiel garantieren.
Erwägen:
@property(atomic, copy) NSString *firstName;
@property(atomic, copy) NSString *lastName;
@property(readonly, atomic, copy) NSString *fullName;
In diesem Fall Thread A das Objekt Umbenennung durch den Aufruf werden könnte setFirstName:und dann anrufen setLastName:. In der Zwischenzeit kann Thread B nennt fullNamezwischen zwei Anrufen Thread A und wird die neuen Vornamen mit dem alten Nachnamen gekoppelt erhalten.
Um dies zu beheben, müssen Sie ein Transaktionsmodell . Dh eine andere Art der Synchronisation und / oder Ausschluss , dass man Zugriff auf ausschließen kann , fullNamewährend die abhängigen Eigenschaften aktualisiert werden.
Dies wird in Apples erklärt Dokumentation , aber unten sind einige Beispiele dafür , was tatsächlich geschieht. Beachten Sie, dass es kein „atomares“ Schlüsselwort ist, wenn Sie die Eigenschaft „nonatomic“ nicht angeben , dann ist atomar, aber die Angabe „atomare“ führen zu einem Fehler explizit zur Folge hat .
//@property(nonatomic, retain) UITextField *userName;
//Generates roughly
- (UITextField *) userName {
return userName;
}
- (void) setUserName:(UITextField *)userName_ {
[userName_ retain];
[userName release];
userName = userName_;
}
Nun ist die Atom-Variante 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 hat die Atom Version eine Sperre zu ergreifen, um die Thread-Sicherheit zu gewährleisten, und auch auf dem Objekt die ref Zählung stoßen (und die Autorelease Zählung es zu balancieren), so dass das Objekt gewährleistet ist für den Anrufer existieren, da sonst Bedingung ist ein potentielles Wettkampfes, wenn ein anderer Thread den Wert einstellt, wodurch der Zählwert Ref auf 0 abzufallen.
Es gibt tatsächlich eine große Anzahl von verschiedenen Varianten, wie diese Dinge funktionieren, je nachdem, ob die Eigenschaften sind skalare Werte oder Objekte und wie zu behalten, zu kopieren, nur lesbar, nonatomic usw. interagieren. Im Allgemeinen weiß die Eigenschaft Synthesizern, wie das „Richtige“ für alle Kombinationen zu tun.
Der beste Weg, um die Differenz wird mit dem folgenden Beispiel zu verstehen.
Angenommen , es ist eine Atom String - Eigenschaft genannt „Name“, und wenn Sie rufen [self setName:@"A"]von Thread A, rufen [self setName:@"B"]aus Thread B, und rufen [self name]vom Gewinde C, dann werden alle Operationen auf verschiedenen Threads werden seriell durchgeführt werden , das heißt , wenn ein Thread einen setter Ausführung oder Getter, dann werden andere Threads warten.
Dies macht Eigenschaft „name“ lesen / schreiben sicher, aber wenn ein anderer Thread, D, ruft [name release]gleichzeitig dann könnte dieser Vorgang einen Absturz erzeugen , weil es keine Setter / Getter Anruf hier beteiligt ist. Das heißt , ein Objekt gelesen wird / Schreib Safe (ATOMIC), aber nicht threadsicher als eine andere Threads gleichzeitig jede Art von Nachrichten an das Objekt senden können. Der Entwickler sollte Thread-Sicherheit für solche Objekte gewährleisten.
Wenn die Eigenschaft „name“ nonatomic war, dann werden alle Threads im obigen Beispiel - A, B, C und D wird ausgeführt, gleichzeitig jede unberechenbare Ergebnis. Im Fall eines Atom entweder ein von A, B oder C wird ausgeführt, die erste, aber noch D parallel ausführen können.
Die Syntax und Semantik sind bereits gut definiert durch andere hervorragende Antworten auf diese Frage. Da die Ausführung und Leistung sind nicht gut detailliert, werde ich meine Antwort hinzufügen.
Was ist der funktionelle Unterschied zwischen diesen 3?
Ich würde immer Atom als Standard betrachtet ziemlich neugierig. An der Abstraktionsebene wir bei der Arbeit, unter Verwendung von Atomeigenschaften für eine Klasse als ein Fahrzeug 100% gewindeSicherheit zu erreichen , ist eine Ecke Fall. Für wirklich richtig multithreaded Programme ist Intervention durch den Programmierer mit ziemlicher Sicherheit eine Voraussetzung. Inzwischen Leistungseigenschaften und die Ausführung noch nicht eingehend detailliert worden. Nachdem sie einige stark multithreaded Programme im Laufe der Jahre geschrieben, ich hatte meine Eigenschaften wie bereits erklärt , nonatomicdie ganze Zeit , weil Atom für jeden Zweck nicht sinnvoll war. Bei der Diskussion der Details der atomaren und nicht - atomare Eigenschaften dieser Frage habe ich einige Profilierung einige merkwürdige Ergebnisse gestoßen.
Ausführung
OK. Das erste , was würde Ich mag zu klären ist , dass die Verriegelungs Implementierung ist die Implementierung definiert und abstrahiert. Louis nutzt @synchronized(self)in seinem Beispiel - ich dies als eine gemeinsame Quelle der Verwirrung gesehen habe. Die Implementierung ist nicht tatsächlich verwenden @synchronized(self); es nutzt Objektebene Spin - Locks . Louis Abbildung ist gut für eine High-Level - Illustration Konstrukte wir alle vertraut sind, aber es ist wichtig zu wissen , dass es nicht verwenden @synchronized(self).
Ein weiterer Unterschied besteht darin, dass atomare Eigenschaften behalten / Release-Zyklus Ihre Objekte innerhalb des Getter.
Performance
Hier ist der interessante Teil: Leistung mit Atom-Eigenschaft in Zugriffe unbestrittenen (zB Single-Threaded) Fälle wirklich sehr schnell in einigen Fällen sein können. In weniger als idealen Fällen, die Verwendung von Atom Zugriffe kann mehr als 20 Mal den Overhead Kosten nonatomic. Während der Contested Fall unter Verwendung von 7 Fäden betrug 44 mal langsamer für den Drei-Byte - struct (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 des synthetisierten nonatomic Accessoren.
Objekte in streitigen Fällen können auch die 50-fache übersteigen.
Aufgrund der Anzahl von Optimierungen und Variationen in Implementierungen, ist es ziemlich schwierig, reale Auswirkungen in diesen Kontexten zu messen. Sie könnten oft so etwas wie „Vertrauen Sie es, wenn Sie das Profil und finden es ist ein Problem“ hören. Aufgrund der Abstraktionsebene, es ist eigentlich ziemlich schwierig tatsächliche Auswirkungen zu messen. Nachlese tatsächlich Kosten von Profilen kann sehr zeitaufwendig sein, und aufgrund Abstraktionen, ziemlich ungenau. Wie gut, ARC vs MRC kann einen großen Unterschied machen.
Also lassen Sie uns einen Schritt zurück, nicht auf die Umsetzung der Eigenschaft Fokussierung Zugriffe werden wir die üblichen Verdächtigen wie umfassen objc_msgSend, und untersuchen einige der realen Welt High-Level - Ergebnisse für viele Anrufe an einen NSStringGetter in unbestrittenen Fällen (Werte in Sekunden):
Wie Sie wahrscheinlich schon erraten haben, Aktivität Referenzzähler / Radfahren ist ein wichtiger Beitrag mit atomics und unter ARC. Sie würden auch größere Unterschiede in strittigen Fällen sehen.
Obwohl ich um die Leistung Aufmerksamkeit schenken, sage ich noch Semantics First! . Inzwischen ist die Leistung eine niedrige Priorität für viele Projekte. Allerdings wissen Ausführungsdetails und Kosten von Technologien , die Sie sicherlich nicht verwenden verletzt. Sie sollten die richtige Technologie für Ihre Bedürfnisse, Zwecke und Fähigkeiten nutzen. Hoffentlich wird dies Ihnen ein paar Stunden Vergleiche sparen und Ihnen helfen, eine besser informierte Entscheidung zu treffen , wenn Ihre Programme zu entwerfen.
Atomic = Gewindesicherheits
Non-atomic = No Thread - Sicherheit
Instanzvariablen sind threadsicher, wenn sie korrekt verhalten, wenn sie von mehreren Threads zugegriffen wird, unabhängig von der Terminplanung oder Verschachtelung der Ausführung dieser Threads von der Laufzeitumgebung und ohne zusätzliche Synchronisation oder Koordination anderen auf dem Teil des anrufenden Code.
Wenn ein Thread, den Wert der Instanz ändert sich der geänderte Wert ist zu allen Fäden vorhanden, und nur ein Thread den Wert zu einem Zeitpunkt ändern kann.
atomic:wenn die Instanz-Variable würde in einer Multithread-Umgebung zugegriffen werden.
atomic:Nicht so schnell wie nonatomicda nonatomicerfordert keine Watchdog - Arbeit an , dass von der Laufzeit.
nonatomic:Wenn die Instanz-Variable werde nicht von mehreren Threads geändert werden können Sie es verwenden. Es verbessert die Leistung.
Ich fand eine ziemlich gut gestellt Erklärung von atomaren und nicht-atomaren Eigenschaften hier . Hier einige relevante Text aus dem gleichen:
‚Atom‘ bedeutet , dass es nicht nach unten gebrochen werden. In O / Programmierung Begriffen ist ein atomarer Funktionsaufruf ein , die nicht unterbrochen werden kann - die gesamte Funktion ausgeführt werden muss, und nicht aus der CPU durch die üblichen Kontext OS getauscht Schalt , bis es fertig ist. Für den Fall , dass Sie nicht wissen: da die CPU nur zu einer Zeit , eine Sache zu tun, dreht sich das OS Zugriff auf die CPU auf alle laufenden Prozesse in kleinen Zeitscheiben, die geben Illusionvon Multitasking. Die CPU-Scheduler kann (und tut) unterbrechen, ein Verfahren an einer beliebigen Stelle in der Ausführung - auch im Hochfunktionsaufruf. Also für Aktionen wie gemeinsame Aktualisierung Zählvariablen wo zwei Prozesse versuchen könnte, die Variable in der gleichen Zeit zu aktualisieren, müssen sie ‚atomar‘ ausgeführt werden, dh jede Update-Aktion hat in seiner Gesamtheit zu beenden, bevor alle anderen Verfahren kann auf die ausgelagert werden ZENTRALPROZESSOR.
Also würde ich raten, dass Atom in diesem Fall bedeutet, dass die Attributleserverfahren kann nicht unterbrochen werden - in der Tat bedeutet, dass die Variable (n) durch das Verfahren gelesen wird, kann nicht ihren Wert Hälfte verändern sich durch, weil einige andere Thread / Anruf / Funktion bekommt auf die CPU getauscht.
Da die atomicVariablen können nicht unterbrochen werden, indem sie der Wert an jedem Punkt enthalten ist (Schraubensicherung) garantiert sein unverdorben , obwohl, sicherstellen , dass diese Gewindesicherung Zugang zu ihnen langsamer macht. non-atomicVariablen, auf der anderen Seite, macht keine solche Garantie aber nicht den Luxus eines schnelleren Zugriff bieten. Um es zusammenzufassen, gehen Sie mit , non-atomicwenn Sie wissen , dass Ihr Variablen nicht von mehreren Threads gleichzeitig und Geschwindigkeit Dinge zugegriffen werden.
so viele Artikel, Stack-Überlauf-Beiträge und machen Demo-Anwendungen zu überprüfen variable Eigenschaft Attribute Nach der Lektüre habe ich beschlossen, alle Informationen, die Attribute zusammen zu stellen:
atomic // Standardnonatomicstrong = retain // Standardweak = unsafe_unretainedretainassign // Standardunsafe_unretainedcopyreadonlyreadwrite // StandardIn den Artikel Variable Eigenschaft Attribute oder Modifikatoren in iOS können Sie alle oben genannten Attribute finden, und das wird definitiv helfen.
atomic
atomic bedeutet, dass nur ein Thread Zugriff auf die Variable (statischen Typ).atomic threadsicher ist.atomic Verhalten ist die StandardeinstellungBeispiel:
@property (retain) NSString *name;
@synthesize name;
nonatomic
nonatomic bedeutet Zugriff auf mehrere Thread die Variable (dynamic-Typ).nonatomic ist gewinde unsicher.nonatomicStandardverhalten nicht. Wir müssen das hinzufügen nonatomicSchlüsselwort in der Eigenschaft Attribute.Beispiel:
@property (nonatomic, retain) NSString *name;
@synthesize name;
Einfachste Antwort zuerst: Es gibt keinen Unterschied zwischen den zweiten zwei Beispiele. Standardmäßig sind, Eigenschaftenaccessoren atomar.
Atomic Accessoren in einer nicht Müll gesammelt Umgebung (dh wenn behalten mit / release / Autorelease) wird eine Sperre, um sicherzustellen, dass ein anderer Thread nicht mit der richtigen Einstellung / getting des Wertes nicht stört.
Siehe „ Leistung und Threading “ Abschnitt von Apples Objective-C 2.0 - Dokumentation für einige weitere Informationen und für andere Überlegungen bei Multi-Threaded - Anwendungen zu schaffen.
Atomic garantiert, dass auf die Eigenschaft zugreifen in einer atomaren Weise durchgeführt werden. ZB zurückgeben immer eine voll Objekte initialisiert, jede get / set einer Eigenschaft auf einem Thread durchführen müssen, bevor ein anderer darauf zugreifen können.
Wenn Sie die folgende Funktion vorstellen, auf zwei Threads auftritt, sofort Sie sehen können, warum würden die Ergebnisse nicht schön sein.
-(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;
}
...
}
Pro: Return of vollständig initialisiert Objekte jedes Mal die beste Wahl bei Multi-Threading macht.
Nachteile: Performance - Einbußen, macht die Ausführung etwas langsamer
Im Gegensatz zu Atomic, ist sicherzustellen, dass es nicht vollständig initialisierte Objekt jedes Mal zurück.
Vorteile: Extrem schnelle Ausführung.
Nachteile: Die Chancen von Müll Wert im Fall von Multi-Threading.
Atomic bedeutet, nur ein Thread greift auf die Variable (statischen Typ). Atomic ist Thread-sicher, aber es ist langsam.
Nonatomic bedeutet, mehrere Threads Zugriff auf die Variable (dynamic-Typ). Nonatomic ist faden unsicher, aber es ist schnell.
Atomic ist Thread - sicher , es ist langsam und es gut versichert (nicht garantiert) , die nur der gesperrte Wert egal vorgesehen ist , wie viele Threads Zugang über die gleiche Zone versuchen. Beim atomic Verwendung wird ein Stück Code innerhalb dieser Funktion geschrieben der Teil des kritischen Abschnitt, an dem nur ein Thread zu einem Zeitpunkt ausführen kann.
Es sichert nur die Thread - Sicherheit; es nicht , dass gewährleisten. Was ich meine ist , dass Sie einen Experten Fahrer für Sie Autovermietung, noch ist es nicht garantiert , Auto nicht einen Unfall treffen. Allerdings Wahrscheinlichkeit bleibt die geringste.
Atomic - es kann nicht abgebaut werden, so dass das Ergebnis zu erwarten ist. Mit nonatomic - wenn ein anderer Thread Zugriff auf die Speicherzone es modifizieren kann, so dass das Ergebnis unerwartet.
Code Diskussion:
Atomic machen Getter und Setter der Immobilie Thread-sicher. wenn u zum Beispiel geschrieben haben:
self.myProperty = value;
threadsicher ist.
[myArray addObject:@"Abc"]
ist nicht Thread-sicher.
Es gibt kein solches Schlüsselwort „atomic“
@property(atomic, retain) UITextField *userName;
Wir können die oben verwenden wie
@property(retain) UITextField *userName;
Siehe Frage Stack - Überlauf erhalte ich Fragen , wenn ich @ Property (atomaren, behalten) verwenden NSString * myString .
Die Standardeinstellung ist atomic, dies bedeutet , dass es Ihnen Leistung kostet , wenn Sie die Eigenschaft verwenden, aber es ist Thread - sicher. Was für Objective-C ist, wird eine Sperre gesetzt, so dass nur der tatsächliche Thread die Variable zugreifen kann, solange die setter / Getter ausgeführt wird.
Beispiel mit MRC einer Immobilie mit einem Ivar _internal:
[_internal lock]; //lock
id result = [[value retain] autorelease];
[_internal unlock];
return result;
Also die letzten beiden sind die gleichen:
@property(atomic, retain) UITextField *userName;
@property(retain) UITextField *userName; // defaults to atomic
Auf der anderen Seite tut nonatomicnichts , um Ihren Code hinzufügen. So ist es nur Thread - sicher , wenn Sie Sicherheitsmechanismus Code selbst.
@property(nonatomic, retain) UITextField *userName;
Die Schlüsselwörter haben gar nicht als erste Eigenschaft Attribut geschrieben werden.
Vergessen Sie nicht, bedeutet dies nicht, dass die Eigenschaft als Ganzes Thread-sicher ist. Nur der Aufruf der Methode des Setter / Getter ist. Aber wenn Sie einen Setter und danach einen Getter zur gleichen Zeit mit zwei verschiedenen Threads verwenden, könnte es auch gebrochen werden!
atomic (default)
Atomic ist der Standard: Wenn Sie nichts eingeben, Ihr Eigentum atomar ist. Eine atomare Eigenschaft ist garantiert, dass, wenn Sie versuchen, von ihm zu lesen, werden Sie einen gültigen Wert zurück. Es macht keine Garantien über das, was dieser Wert sein könnte, aber Sie werden gute Daten zurückkommen, nicht nur Junk-Speicher. Was dies ermöglicht es Ihnen ist zu tun, wenn Sie an einer einzigen Variablen mehrere Threads oder mehrere Prozesse zeigen, kann ein Thread lesen und ein anderer Thread schreiben. Wenn sie zur gleichen Zeit treffen, wird der Leser Faden garantiert einen der beiden Werte zu erhalten: entweder vor der Änderung oder nach der Änderung. Was Atom sind Sie nicht irgendeine Art von Garantie über welche diese Werte, die Sie bekommen könnten. Atomic ist wirklich häufig verwechselt mit Thread-sicher zu sein, und das ist nicht richtig. Sie benötigen eine Thread-Sicherheit andere Möglichkeiten zu gewährleisten. Atom wird jedoch garantieren, dass, wenn Sie zu lesen versuchen, Sie irgendeine Art von Wert zurück.
nonatomic
Auf der anderen Seite, nicht-atomar, wie Sie wahrscheinlich erraten können, bedeutet nur, „tut das nicht atomar Sachen.“ Was Sie verlieren ist, dass Garantie, dass Sie immer wieder etwas bekommen. Wenn Sie versuchen, in der Mitte eines Schreib zu lesen, könnten Sie Müll Daten zurück. Aber auf der anderen Seite, gehen Sie ein wenig schneller. Da atomare Eigenschaften etwas Magie zu tun haben, um sicherzustellen, dass Sie einen Wert zurückerhalten, sie sind ein bisschen langsamer. Wenn es eine Eigenschaft ist, dass Sie eine Menge zugreifen, können Sie bis zu nonatomic fallen, um sicherzustellen, dass Sie nicht, dass die Geschwindigkeit Strafe werden entstehen.
Mehr Infos hier: https://realm.io/news/tmi-objective-c-property-attributes/
Wie zu erklären:
Als Atom Standard ist so,
@property (retain) NSString *name;
UND in Implementierungsdatei
self.name = @"sourov";
Nehmen wir an, eine Aufgabe im Zusammenhang mit drei Eigenschaften sind
@property (retain) NSString *name;
@property (retain) NSString *A;
@property (retain) NSString *B;
self.name = @"sourov";
Alle Objekte arbeiten parallel (wie asynchron).
Wenn Sie „name“ aus Thread nennen A ,
Und
Zur gleichen Zeit, wenn Sie anrufen
[self setName:@"Datta"]
Vom Faden B ,
Jetzt Wenn * Name Eigenschaft ist nonatomic dann
Das ist, warum nicht atomar ist Thread unsicher genannt Aber, aber es ist schnell in der Leistung wegen der parallelen Ausführung
Jetzt Wenn * Name Eigenschaft ist atomar
Deshalb Atom ist die Threadsicherheit genannt und das ist , warum es heißt Lese-Schreib - Safe
Eine solche Situation Operation wird seriell auszuführen. Und langsam in der Leistung
- nichtatomare bedeutet mehrere Threadzugriff die Variable (dynamic-Typ).
- nichtatomare ist unsicher fädeln.
- aber es ist schnell in der Leistung
-Nonatomic NICHT Standardverhalten, müssen wir nonatomic Stichwort in Eigenschaftsattribut hinzufügen.
Bestätigen für In Swift, dass Swift Eigenschaften nonatomic sind im ObjC Sinn. Ein Grund dafür ist, so dass Sie darüber nachdenken, ob pro Eigenschaft Unteilbarkeit für Ihre Bedürfnisse ausreicht.
Referenz: https://forums.developer.apple.com/thread/25642
Fro weitere Informationen besuchen Sie bitte die Website http://rdcworld-iphone.blogspot.in/2012/12/variable-property-attributes-or.html
Wenn Sie Ihre Immobilie in Multi-Threaded-Code verwenden, dann würden Sie in der Lage sein, den Unterschied zwischen nonatomic und atomaren Eigenschaften zu sehen. Nonatomic ist schneller als Atom- und Atom ist Thread-sicher, nicht nonatomic.
Vijayendra Tripathi hat bereits ein Beispiel für eine Multi-Threaded-Umgebung gegeben.
Bevor Sie beginnen: Sie müssen wissen , dass jedes Objekt im Speicher aus dem Speicher werden ausgeplant muss für eine neue Schreib geschehen. Sie können nicht nur einfach oben auf etwas schreiben , wie Sie es auf Papier tun. Sie müssen zuerst (dealloc) es löschen und dann kann man auf sie schreiben. Wenn im Moment , dass der Lösch erfolgt (oder halb fertig) und nichts hat noch geschrieben worden ist (oder die Hälfte geschrieben hat) und Sie versuchen , zu lesen , könnte es sehr problematisch sein! Atomic und nonatomic Hilfe behandeln Sie dieses Problem auf unterschiedliche Weise.
Lesen Sie zuerst diese Frage und dann lesen BBUM Antwort . Außerdem lesen Sie dann meine Zusammenfassung.
atomic IMMER garantieren
Bewahren Sie zählt , sind die Art und Weise , in der Speicher in Objective-C verwaltet wird. Wenn Sie ein Objekt erstellen, ist es eine Zählung von 1. behalten hat , wenn Sie eine Nachricht behält ein Objekt senden, seine Beibehaltungszähler um 1 erhöht wird , wenn Sie ein Objekt Release - Nachricht senden, wird sein Beibehaltungszähler um 1 verringert , wenn Sie ein Objekt eine senden Autofreigabe Nachricht , seine Beibehaltungszähler um 1 zu einem bestimmten Zeitpunkt in der Zukunft verringert. Wenn ein object's Zahl beibehalten wird auf 0 reduziert wird , wird es freigegeben.
Warte was?! Ist Multithreading und Thread - Sicherheit anders?
Ja. Multithreading bedeutet: mehrere Threads ein gemeinsames Stück von Daten zur gleichen Zeit lesen können und wir werden nicht abstürzen, aber es garantiert nicht, dass Sie nicht von einem Nicht-Autoreleased Wert lesen. Mit Thread-Sicherheit, es ist garantiert, dass das, was Sie lesen nicht automatisch freigegeben ist. Der Grund, dass wir ist nicht alles Atomstandardmäßig machen, weil es eine Leistungskosten und für die meisten Dinge nicht wirklich Thread-Sicherheit benötigen. Einige Teile unseres Code benötigen sie und für die wenigen Teile müssen wir unseren Code in einem Thread sichere Art und Weise mit Schlössern, Mutex oder Synchronisation schreiben.
nonatomic
Insgesamt sind sie in zwei Aspekten anders:
Abstürzt oder nicht, weil der mit oder ohne Autorelease Pool.
Unter Berücksichtigung in der Mitte eines ‚noch nicht fertig schreiben oder leeren Wertes‘ oder nicht richtig gelesen werden , so dass nur zu lesen , so dass , wenn der Wert ist voll geschrieben.
Vor der Diskussion über die Attribute von @property, sollten Sie wissen, was die Verwendung von @property ist. @property bietet eine Möglichkeit, die Informationen zu definieren, die eine Klasse kapseln soll. Wenn Sie ein Objekt / Variable @property deklarieren, dann ist das Objekt / Variable auf andere Klassen importieren seiner Klasse zugänglich sein. Wenn Sie ein Objekt mit @property in der Header-Datei deklarieren, dann haben Sie es zu synthetisieren, in der Implementierungsdatei mit @synthesize.
Beispiel:
.h Klasse
@interface ExampleClass : NSObject
@property (nonatomic, retain) NSString *name;
@end
.m Klasse
@implementation ExampleClass
@synthesize name;
@end
Nun wird der Compiler Accessormethoden für Namen synthetisieren.
ExampleClass *newObject=[[ExampleClass alloc]init];
NSString *name1=[newObject name]; // get 'name'
[obj setName:@“Tiger”];
Liste der Attribute von @property: atomar. nonatomic. behalten. Kopieren. schreibgeschützt. lesen Schreiben. zuordnen. stark.
Atom: Es ist das Standardverhalten. Wenn ein Objekt als Atom deklariert wird, dann wird es Thread-sicher. Thread-safe-Einrichtung, zu einem Zeitpunkt nur ein Thread einer bestimmten Instanz dieser Klasse kann, hat die Kontrolle über das Objekt.
Beispiel:
@property NSString *name; //by default atomic
@property (atomic)NSString *name; // explicitly declared atomic
nonatomic: Es ist nicht Thread-sicher. Sie können die nicht-atomare Eigenschaft Attribut verwenden, um die synthetisiert Accessoren geben Sie einfach eingestellt oder direkt einen Wert zurückgeben, ohne Garantien über das, was passiert, wenn diese denselben Wert gleichzeitig von verschiedenen Threads zugegriffen wird. Aus diesem Grunde ist es schneller eine nicht-atomare Eigenschaft als ein Atom einer zuzugreifen.
@property (nonatomic)NSString *name;
behalten: erforderlich, wenn das Attribut ein Zeiger auf eine Objekts.Verfahren Setter-Methode ist erhöht Zählung des Objekts beibehalten, so dass es Speicher in Autofreigabepool besetzen wird.
@property (retain)NSString *name;
Kopie: Wenn Sie Kopie verwenden, können Sie nicht behalten verwenden. Kopie Instanz der Klasse verwendet, wird seine eigene Kopie enthalten. Selbst wenn eine veränderbare Zeichenfolge festgelegt wird und anschließend geändert wird, fängt die Instanz, was Wert, den es zur Zeit hat es gesetzt ist. Keine Setter und Getter-Methoden werden synthetisiert.
@property (copy) NSString *name;
NSMutableString *nameString = [NSMutableString stringWithString:@"Liza"];
xyzObj.name = nameString;
[nameString appendString:@"Pizza"];
Read-only: Wenn Sie die Eigenschaft über Setter-Methode geändert werden nicht zulassen wollen, können Sie die Eigenschaft Read-only erklären.
@property (readonly) NSString *name;
Lese-Schreib-: ist das Standardverhalten. Sie brauchen keine Lese-Schreib-Attribut explizit angeben.
@property (readwrite) NSString *name;
zuzuordnen: einen setter erzeugen, die den Wert auf die Instanzvariable, anstatt das Kopieren oder Halte direkt zuordnet. Dies ist am besten für primitive Typen wie NSInteger und CGFloat oder Objekte, die Sie nicht direkt, wie die Delegierten besitzen.
@property (assign) NSInteger year;
stark: ist ein Ersatz für behalten.
@property (nonatomic, strong) AVPlayer *player;
unsafe_unretained: Es gibt ein paar Klassen in Cocoa und Cocoa Touch, die noch keinen schwachen Verweis unterstützen, was bedeutet, dass Sie nicht eine schwache Eigenschaft oder schwache lokale Variable, um zu verfolgen, sie erklären können. Diese Klassen umfassen NSTextView, NSFont und NSColorSpace usw. Wenn Sie einen schwachen Verweis auf eine dieser Klassen verwenden müssen, müssen Sie eine unsichere Referenz verwenden. Eine unsichere Referenz ähnelt einem schwachen Verweis, dass es hält nicht mit ihrem verbundenen Objekt am Leben, aber es wird nicht auf Null gesetzt werden, wenn das Zielobjekt ist freigegeben.
@property (unsafe_unretained) NSObject *unsafeProperty;
Die atomare Eigenschaft sorgt für eine vollständig initialisierte Wert unabhängig von behalten, wie viele Threads Getter & Setter auf es tun.
Die nicht-atomare Eigenschaft gibt an, dass synthetisierte Accessoren einfach direkt einen Wert eingestellt oder zurückgeben, ohne Garantien über das, was passiert, wenn diese denselben Wert gleichzeitig von verschiedenen Threads zugegriffen wird.
Atomic bedeutet, nur ein Thread die Variable zu einem Zeitpunkt zugreifen kann (statischer Typ). Atomic ist Thread-sicher, aber es ist langsam.
Nonatomic bedeutet, mehrere Threads die Variable zur gleichen Zeit zugreifen können (dynamisch-Typ). Nonatomic ist faden unsicher, aber es ist schnell.
Wenn Sie Atom verwenden, bedeutet dies, der Faden sicher sein wird und schreibgeschützt. Wenn Sie die nicht-atomare verwenden, bedeutet dies, die mehrere Threads auf die Variable zugreifen und ist Thread unsicher, aber es wird schnell ausgeführt, eine Lese- und Schreiboperationen durchgeführt; Dies ist ein dynamischer Typ.
Atomicity Atom (default)
Atomic ist der Standard: Wenn Sie nichts eingeben, Ihr Eigentum atomar ist. Eine atomare Eigenschaft ist garantiert, dass, wenn Sie versuchen, von ihm zu lesen, werden Sie einen gültigen Wert zurück. Es macht keine Garantien über das, was dieser Wert sein könnte, aber Sie werden gute Daten zurückkommen, nicht nur Junk-Speicher. Was dies ermöglicht es Ihnen ist zu tun, wenn Sie an einer einzigen Variablen mehrere Threads oder mehrere Prozesse zeigen, kann ein Thread lesen und ein anderer Thread schreiben. Wenn sie zur gleichen Zeit treffen, wird der Leser Faden garantiert einen der beiden Werte zu erhalten: entweder vor der Änderung oder nach der Änderung. Was Atom sind Sie nicht irgendeine Art von Garantie über welche diese Werte, die Sie bekommen könnten. Atomic ist wirklich häufig verwechselt mit Thread-sicher zu sein, und das ist nicht richtig. Sie benötigen eine Thread-Sicherheit andere Möglichkeiten zu gewährleisten. Atom wird jedoch garantieren, dass, wenn Sie zu lesen versuchen, Sie irgendeine Art von Wert zurück.
nonatomic
Auf der anderen Seite, nicht-atomar, wie Sie wahrscheinlich erraten können, bedeutet nur, „tut das nicht atomar Sachen.“ Was Sie verlieren ist, dass Garantie, dass Sie immer wieder etwas bekommen. Wenn Sie versuchen, in der Mitte eines Schreib zu lesen, könnten Sie Müll Daten zurück. Aber auf der anderen Seite, gehen Sie ein wenig schneller. Da atomare Eigenschaften etwas Magie zu tun haben, um sicherzustellen, dass Sie einen Wert zurückerhalten, sie sind ein bisschen langsamer. Wenn es eine Eigenschaft ist, dass Sie eine Menge zugreifen, können Sie bis zu nonatomic fallen, um sicherzustellen, dass Sie nicht, dass die Geschwindigkeit Strafe werden entstehen. Zugriff
mit freundlicher Genehmigung https://academy.realm.io/posts/tmi-objective-c-property-attributes/
Atomarität Eigenschaftsattribute (atomic und nonatomic) nicht in der entsprechenden Eigenschaft Swift Erklärung reflektieren, aber die Atomarität Garantien der Objective-C Implementierung immer noch halten, wenn die eingeführte Eigenschaft von Swift zugegriffen wird.
Also - wenn Sie eine atomare Eigenschaft in Objective-C definieren wird es Atom bleiben, wenn sie von Swift verwendet.
mit freundlicher Genehmigung https://medium.com/@YogevSitton/atomic-vs-non-atomic-properties-crash-course-d11c23f4366c
Atomic Eigenschaften : - Wenn eine Variable mit atomaren Eigenschaft zugeordnet, bedeutet es nur ein Thread Zugriff hat , und es wird Thread - sicher und wird in Hinblick auf die Leistung gut sein, wird das Standardverhalten haben.
Nicht Atomic Eigenschaften : - Wenn eine Variable mit atomaren Eigenschaft zugeordnet, bedeutet dies , Multi - Thread - Zugang hat , und es wird nicht sicher sein Gewinde und wird in Hinblick auf die Leistung langsam sein, wird das Standardverhalten haben und wenn zwei verschiedene Threads wollen bei gleichzeitig Variable zuzugreifen es wird zu unerwarteten Ergebnissen führen.
Die Wahrheit ist, dass sie Spin-Lock verwenden Atom Eigenschaft zu implementieren. Der Code wie folgt:
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);
}
Um die gesamte Verwirrung zu vereinfachen lassen Sie uns Mutex lock.Mutex Sperre verstehen gemäß dem Namen der Veränderlichkeit des object.So sperrt, wenn das Objekt durch eine Klasse keine andere Klasse zugegriffen wird, kann die gleiche object.In iOS @sychronise auch Zugriff auf den Mutex bieten lock.Now es im FIFO-Modus dienen und sorgt für die Strömung nicht durch zwei Klassen teilen die gleiche instance.However, wenn die Aufgabe auf Hauptthread vermeiden Zugriff auf Objekt mit atomaren Eigenschaften, wie es Ihre UI und die Leistung ist beeinträchtigt wird degradieren halten kann
Atomic: Sicherstellen, Thread-Sicherheit durch den Faden NSLOCK Verwendung zu verriegeln.
Nicht Atom: Hat Thread-Sicherheit nicht gewährleisten, da es keinen Gewindesicherungsmechanismus ist.