Was ist der Unterschied zwischen den atomaren und nichtatomaren Attributen?

Question

Was tun atomic y nonatomic in Eigenschaftserklärungen bedeuten?

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

Was ist der operative Unterschied zwischen diesen drei?

Answer 1

Atomic bedeutet, dass jeweils nur ein Thread auf die Variable zugreifen kann (statischer Typ). Atomic ist thread-sicher, aber langsam.

Nichtatomar bedeutet, dass mehrere Threads gleichzeitig auf die Variable zugreifen können (dynamischer Typ). Nonatomic ist thread-unsicher, aber schnell.

Answer 2

Die Wahrheit ist, dass sie Spin Lock verwenden, um die atomare Eigenschaft zu implementieren. Der Code wie unten:

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

Answer 3

In einer einzigen Zeile:

Atomic ist thread-sicher. Nonatomic ist thread-unsicher.

Answer 4

Atomar: Gewährleistung der Thread-Sicherheit durch Sperren des Threads mit NSLOCK.

Nicht atomar: Gewährleistet keine Thread-Sicherheit, da es keinen Thread-Locking-Mechanismus gibt.

Answer 5

Wenn Sie atomar arbeiten, bedeutet dies, dass der Thread sicher und schreibgeschützt ist. Wenn Sie nonatomic verwenden, bedeutet dies, dass mehrere Threads auf die Variable zugreifen und dass sie threadunsicher ist, aber schnell ausgeführt wird und Lese- und Schreiboperationen ausführt; dies ist ein dynamischer Typ.