ios 12 download - Qual è la differenza tra gli attributi atomici e non anatomici?





13 Answers

Questo è spiegato nella documentation di Apple, ma di seguito sono riportati alcuni esempi di ciò che sta realmente accadendo. Si noti che non esiste una parola chiave "atomica", se non si specifica "nonatomico", la proprietà è atomica, ma specificando "atomico" esplicitamente si verificherà un errore.

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

- (UITextField *) userName {
    return userName;
}

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

Ora, la variante atomica è un po 'più complicata:

//@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_;
    }
}

Fondamentalmente, la versione atomica deve prendere un lock per garantire la sicurezza del thread, e anche il conteggio dei ref sull'oggetto (e il conteggio automatico per bilanciarlo) in modo che l'oggetto sia garantito per il chiamante, altrimenti lì è una potenziale condizione di competizione se un altro thread sta impostando il valore, facendo cadere il conteggio dei ref a 0.

Esistono in realtà un gran numero di diverse varianti di come funzionano queste cose a seconda che le proprietà siano valori o oggetti scalari e come interagire tra conservazione, copia, sola lettura, non anatomica, ecc. In generale i sintetizzatori di proprietà sanno solo come fare la "cosa giusta" per tutte le combinazioni.

beta 11 rilascio

Che cosa significano atomic e non nonatomic nelle dichiarazioni di proprietà?

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

Qual è la differenza operativa tra questi tre?




Il modo migliore per capire la differenza è usare il seguente esempio.

Supponiamo che ci sia una proprietà di stringa atomica chiamata "nome", e se chiami [self setName:@"A"] dal thread A, chiama [self setName:@"B"] dal thread B e chiama [self name] da thread C, quindi tutte le operazioni su thread diversi verranno eseguite in serie, il che significa che se un thread sta eseguendo un setter o un getter, allora altri thread attenderanno.

Questo rende la proprietà "nome" in lettura / scrittura sicura, ma se un altro thread, D, chiama [name release] contemporaneamente, questa operazione potrebbe causare un arresto anomalo perché non è presente alcuna chiamata setter / getter. Ciò significa che un oggetto è in lettura / scrittura sicuro (ATOMIC), ma non thread-safe poiché un altro thread può inviare contemporaneamente qualsiasi tipo di messaggio all'oggetto. Lo sviluppatore dovrebbe garantire la sicurezza del thread per tali oggetti.

Se il "nome" della proprietà era nonatomico, tutti i thread nell'esempio precedente - A, B, C e D verranno eseguiti simultaneamente producendo risultati imprevedibili. In caso di atomico, uno di A, B o C verrà eseguito per primo, ma D può ancora essere eseguito in parallelo.




Atomico = sicurezza del filo

Non atomico = Nessuna sicurezza del filo

Sicurezza filo:

Le variabili di istanza sono thread-safe se si comportano correttamente quando si accede da più thread, indipendentemente dalla pianificazione o interleaving dell'esecuzione di tali thread da parte dell'ambiente di runtime e senza sincronizzazione aggiuntiva o altro coordinamento sulla parte del codice chiamante.

Nel nostro contesto:

Se un thread modifica il valore dell'istanza, il valore modificato è disponibile per tutti i thread e solo un thread può modificare il valore alla volta.

Dove usare l' atomic :

se la variabile di istanza sarà accessibile in un ambiente con multithreading.

Implicazione di atomic :

Non veloce come non nonatomic perché nonatomic non richiede alcun lavoro di watchdog su quello da runtime.

Dove usare nonatomic :

Se la variabile di istanza non verrà modificata da più thread, puoi usarla. Migliora le prestazioni.




Dopo aver letto tanti articoli, i messaggi e le applicazioni demo per controllare gli attributi delle proprietà variabili, ho deciso di mettere insieme tutte le informazioni sugli attributi:

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

Nell'articolo Attributi o modificatori di proprietà variabili in iOS puoi trovare tutti gli attributi sopra menzionati e questo ti aiuterà sicuramente.

  1. atomic

    • atomic significa che solo un thread accede alla variabile (tipo statico).
    • atomic è thread sicuro.
    • Ma è lento nelle prestazioni
    • atomic è il comportamento predefinito
    • Gli accessor atomici in un ambiente non garbage collection (ossia quando si utilizza retain / release / autorelease) utilizzeranno un lock per assicurarsi che un altro thread non interferisca con l'impostazione / acquisizione corretta del valore.
    • In realtà non è una parola chiave.

    Esempio:

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

    • nonatomic significa accesso multiplo alla variabile (tipo dinamico).
    • nonatomic è sicuro per il thread.
    • Ma è veloce nelle prestazioni
    • nonatomic NON è un comportamento predefinito. Abbiamo bisogno di aggiungere la parola chiave non nonatomic nell'attributo della proprietà.
    • Può comportare un comportamento imprevisto quando due diversi processi (thread) accedono alla stessa variabile nello stesso momento.

    Esempio:

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



Atomico:

Atomic garantisce che l'accesso alla proprietà sarà eseguito in modo atomico. Ad esempio, restituisce sempre un oggetto completamente inizializzato, qualsiasi get / set di una proprietà su un thread deve essere completato prima che un altro possa accedervi.

Se si immagina che la seguente funzione che si verifica su due thread contemporaneamente, si possa capire perché i risultati non sarebbero belli.

-(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: il ritorno di oggetti completamente inizializzati ogni volta rende la scelta migliore in caso di multi-threading.

Contro: Colpo di prestazioni, rende l'esecuzione un po 'più lenta

Non Atomico:

A differenza di Atomic, non garantisce ogni volta il ritorno dell'oggetto completamente inizializzato.

Pro: esecuzione estremamente veloce.

Contro: Probabilità di valore spazzatura in caso di multi-threading.




Atomic è thread-safe , è lento e garantisce (non è garantito) che solo il valore bloccato è fornito indipendentemente dal numero di thread che tentano di accedere alla stessa zona. Quando si utilizza atomico, un pezzo di codice scritto all'interno di questa funzione diventa la parte della sezione critica, alla quale può essere eseguito un solo thread alla volta.

Assicura solo la sicurezza del filo; non lo garantisce. Ciò che intendo è che noleggi un autista esperto per la tua auto, tuttavia non garantisce che la macchina non incontri un incidente. Tuttavia, la probabilità rimane la minima.

Atomico: non può essere scomposto, quindi il risultato è previsto. Con nonatomico - quando un altro thread accede alla zona della memoria, può modificarlo, quindi il risultato è inaspettato.

Discorso a codice:

Atomic rende sicuro getter e setter del thread di proprietà. per esempio se hai scritto:

self.myProperty = value;

è thread-safe

[myArray addObject:@"Abc"] 

NON è thread sicuro.




Il valore predefinito è atomic , questo significa che ti costa la tua prestazione ogni volta che usi la proprietà, ma è thread-safe. Che cosa fa l'Objective-C, è impostato un lock, quindi solo la thread effettiva può accedere alla variabile, fintanto che il setter / getter viene eseguito.

Esempio con MRC di una proprietà con un ivar _internal:

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

Quindi questi ultimi due sono gli stessi:

@property(atomic, retain) UITextField *userName;

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

D'altra parte nonatomic non aggiunge nulla al tuo codice. Quindi è sicuro solo se si codifica il meccanismo di sicurezza da soli.

@property(nonatomic, retain) UITextField *userName;

Le parole chiave non devono essere scritte come primo attributo di proprietà.

Non dimenticare, questo non significa che la proprietà nel suo insieme sia sicura per i thread. È solo la chiamata al metodo del setter / getter. Ma se usi un setter e dopo un getter allo stesso tempo con 2 thread diversi, potrebbe essere rotto anche tu!




Prima di discutere degli attributi di @property, dovresti sapere a cosa serve @property. @property offre un modo per definire le informazioni che una classe intende incapsulare. Se dichiari un oggetto / variabile usando @property, quell'oggetto / variabile sarà accessibile ad altre classi che importano la sua classe. Se dichiari un oggetto usando @property nel file di intestazione, devi sintetizzarlo usando @synthesize nel file di implementazione.

Esempio:

classe .h

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

.m classe

@implementation ExampleClass
   @synthesize name;
@end

Ora il compilatore sintetizzerà i metodi di accesso per il nome.

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

Elenco di attributi di @property: atomic. nonatomic. conservare. copia. sola lettura. leggere scrivere. assegnare. forte.

atomico: è il comportamento predefinito. Se un oggetto viene dichiarato atomico, diventa sicuro per i thread. Mezzi thread-safe, in un momento solo un thread di una particolare istanza di quella classe può avere il controllo su quell'oggetto.

Esempio :

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

nonatomico: non è thread-safe. È possibile utilizzare l'attributo della proprietà nonatomico per specificare che gli accessori sintetizzati semplicemente impostano o restituiscono un valore direttamente, senza garanzie su ciò che accade se si accede allo stesso valore contemporaneamente da diversi thread. Per questo motivo, è più veloce accedere a una proprietà nonatomica che a una atomica. @property (nonatomic)NSString *name;

retain: è richiesto quando l'attributo è un puntatore a un oggetto. Il metodo setter aumenterà il conteggio del mantenimento dell'oggetto, in modo che occupi memoria nel pool autorelease. @property (retain)NSString *name;

copia: se si utilizza la copia, non è possibile utilizzare la conservazione. L'utilizzo dell'istanza di copia della classe conterrà la propria copia. Anche se viene impostata una stringa mutabile e successivamente modificata, l'istanza acquisisce il valore che ha nel momento in cui è impostata. Nessun metodo setter e getter sarà sintetizzato.

@property (copy) NSString *name;

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

readonly: se non si desidera consentire la modifica della proprietà tramite il metodo setter, è possibile dichiarare la proprietà in sola lettura. @property (readonly) NSString *name;

readwrite: è il comportamento predefinito. Non è necessario specificare esplicitamente l'attributo readwrite.

@property (readwrite) NSString *name;

assign: genererà un setter che assegna direttamente il valore alla variabile di istanza, piuttosto che copiarlo o mantenerlo. Questo è il migliore per i tipi primitivi come NSInteger e CGFloat o gli oggetti che non possiedi direttamente, come i delegati.

@property (assign) NSInteger year;

forte: è un sostituto per conservare. @property (nonatomic, strong) AVPlayer *player;

unsafe_unretained: ci sono alcune classi in Cocoa e Cocoa Touch che non supportano ancora riferimenti deboli, il che significa che non è possibile dichiarare una proprietà debole o una variabile locale debole per tenerne traccia. Queste classi includono NSTextView, NSFont e NSColorSpace, ecc. Se è necessario utilizzare un riferimento debole a una di queste classi, è necessario utilizzare un riferimento non sicuro. Un riferimento non sicuro è simile a un riferimento debole in quanto non mantiene attivo il relativo oggetto correlato, ma non verrà impostato su zero se l'oggetto di destinazione è deallocato.

@property (unsafe_unretained) NSObject *unsafeProperty;




  • -Atomico significa che solo un thread accede alla variabile (tipo statico).
  • -Atomic è thread-safe.
  • -ma è lento nelle prestazioni

Come dichiarare:

Siccome l'atomico è di default così,

@property (retain) NSString *name;

E nel file di implementazione

self.name = @"sourov";

Supponiamo che un'attività sia correlata a tre proprietà

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

Tutte le proprietà funzionano parallelamente (come in modo asincrono).

Se chiami "nome" dal thread A ,

E

Allo stesso tempo, se chiami

[self setName:@"Datta"]

dalla discussione B ,

Ora Se * nome proprietà non è anatomico allora

  • Restituirà il valore "Datta" per A
  • Restituirà il valore "Datta" per B

Ecco perché non atomico è chiamato thread non sicuro, ma è veloce nelle prestazioni a causa dell'esecuzione parallela

Ora Se * la proprietà nome è atomica

  • Garantirà valore "Sourov" per A
  • Quindi restituirà il valore "Datta" per B

Ecco perché atomic si chiama thread Safe ed è per questo che si chiama read-write safe

Tale operazione di situazione si realizzerà in serie. E lento nelle prestazioni

- Nonatomico significa accesso multiplo alla variabile (tipo dinamico).

- Nonatomic è thread non sicuro.

- ma è veloce nelle prestazioni

-Nonatomico NON è un comportamento predefinito, dobbiamo aggiungere una parola chiave non anatomica nell'attributo della proprietà.

For In Swift Conferma che le proprietà di Swift non sono anatomiche nel senso ObjC. Una ragione è quindi che pensi se l'atomicità per proprietà sia sufficiente per le tue esigenze.

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

Per maggiori informazioni visita il sito http://rdcworld-iphone.blogspot.in/2012/12/variable-property-attributes-or.html




La proprietà atomica garantisce di mantenere un valore completamente inizializzato indipendentemente dal numero di thread che stanno eseguendo getter & setter su di esso.

La proprietà nonatomica specifica che gli accessori sintetizzati semplicemente impostano o restituiscono un valore direttamente, senza garanzie su ciò che accade se si accede allo stesso valore contemporaneamente da diversi thread.




Se si utilizza atomico, significa che il thread sarà sicuro e di sola lettura. Se si utilizza nonatomico, significa che più thread accedono alla variabile e non è sicuro, ma viene eseguito velocemente, esegue operazioni di lettura e scrittura; questo è un tipo dinamico.




Per semplificare l'intera confusione, comprendiamo il blocco mutex.Mutex lock come per il nome blocca la mutabilità dell'oggetto.Così se l'oggetto è accessibile da una classe nessun altra classe può accedere allo stesso oggetto.In iOS @sychronise fornisce anche il mutex lock.Ora serve in modalità FIFO e garantisce che il flusso non sia influenzato da due classi che condividono la stessa istanza. Tuttavia, se l'attività si trova sul thread principale, evitare l'accesso all'oggetto usando proprietà atomiche poiché potrebbe contenere l'interfaccia utente e degradare le prestazioni




Proprietà atomiche : - Quando una variabile assegnata con proprietà atomiche significa che ha solo un accesso al thread e sarà thread-safe e sarà buona in prospettiva delle prestazioni, avrà un comportamento predefinito.

Proprietà non atomiche : - Quando una variabile assegnata con proprietà atomiche significa che ha accesso multi-thread e non sarà thread-safe e sarà lenta in prospettiva delle prestazioni, avrà un comportamento predefinito e quando due thread differenti vogliono accedere alla variabile contemporaneamente darà risultati inaspettati.






Related