The difference between (assign, retain, copy, weak, strong) in IOS and the meaning of nonatomic
When we declare the @property attribute, we always write one of assign, retain, copy, weak, and strong in brackets. Many times, we just write the one we often write according to our habits, but sometimes when we look at the code, we will find that others use it differently. So what is the difference between these?
First of all, the above five are not on the same level and can be divided into two parts. The first part is assign, retain, and copy, and the second part is weak and strong.
Let’s first talk about the assignment, retain, and copy in the first part.
assign：
Assign is generally used to modify basic data types, including basic data types (NSInteger, CGFloat) and C data types (int, float, double, char, etc.). Why? The attribute declared by assign will not increase the reference count, which means that after the declared attribute is released, it will be gone. Even if other objects use it, they cannot retain it and will only crash. However, even if it is released, the pointer is still there and becomes a wild pointer. If a new object is allocated to this memory address, it will crash. Therefore, it is generally only used to declare basic data types, because they will be allocated to the stack, and the stack will be automatically processed by the system and will not cause wild pointers.
retain：
In contrast to assign, if we want to solve the problem caused by the object being referenced by other objects, we must use retain to declare it. The object declared after retain will change the reference count. Then every time it is referenced, the reference count will be +1, and it will be -1 after release. Even if the object itself is released, as long as the object is still referenced, it will be held, which will not cause any problem. Only when the reference count is 0, the memory will be recycled by the dealloc destructor.
copy：
The most common copy declaration should be NSString. The difference between copy and retain is that the reference of retain is the copy pointer address, while copy is the copy object itself, that is, retain is shallow copy, and copy is deep copy. If it is shallow copy, it will be modified when the object value is modified, while deep copy will not. The reason why it is used on objects of mutable types such as NSString is that they may be assigned to the corresponding mutable types such as NSMutableString. In order to prevent the content from being changed, copy is used to copy deeply. Copy work is performed by the copy method, and this property is only valid for object types that implement the NSCopying protocol.
The above three can be used in MRC, but weak and strong can only be used in ARC, that is, automatic reference counting. At this time, you cannot manually perform retain, release and other operations. ARC will help us complete these tasks.
weak：
Weak is actually similar to assign, called weak reference, and does not increase the reference count. Generally, it is only used when preventing circular references. For example, the parent class refers to a subclass, and the subclass refers to the parent class. IBOutlets and Delegate generally use weak, because they will be called outside the class to prevent circular references.
strong：
Relatively, strong is similar to retain, called strong reference, which will increase the reference count. The attributes used within the class are generally modified by strong. Now ARC has basically replaced MRC, so the most common thing we are strong.
nonatomic：
When modifying attributes, we often add a nonatomic, what is this? Its name is non-atomic access。 Corresponding areatomic，It is an atomic access。 We know that when using multithreading, in order to avoid problems caused by writing at the same time during write operations, the object to be written is often locked, that is, only one thread is allowed to operate it at the same time. If an attribute is modified by atomic, the system will perform thread protection to prevent multiple write operations from being performed simultaneously. This has advantages, but also disadvantages, that is, it consumes system resources. Therefore, for small devices like iPhones, if you do not perform multi-threaded write operations, you can use nonatomic to cancel thread protection and improve performance.
Thank you for reading, I hope it can help you. Thank you for your support for this site!