Variable property attributes or Modifiers in iOS

After reading so many Articles, SO posts and made demo apps to check Variable property attributes, I decided to put all the attributes information together

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

Article is from：Variable property attributes or Modifiers in iOS

01. atomic 

-Atomic means only one thread access the variable(static type). -Atomic is thread safe. -but it is slow in performance -atomic is default behavior -Atomic accessors in a non garbage collected environment (i.e. when using retain/release/autorelease) will use a lock to   ensure that another thread doesn't interfere with the correct setting/getting of the value. -it is not actually a keyword.

Example :

@property (retain) NSString *name;

@synthesize name;
           

總結：設定成員變量的@property屬性時，預設為atomic，提供多線程安全。在多線程下，提供原子操作是必要的，否則容易出錯。atomic是Objc使用的一種線程保護技術，基本上來講，是防止在寫未完成的時候被另外一個線程讀取，造成資料錯誤。而這種機制是耗費系統資源的，是以在iPhone這種小型裝置上，如果沒有使用多線程間的通訊程式設計，那麼nonatomic是一個非常好的選擇。

02. nonatomic

-Nonatomic means multiple thread access the variable(dynamic type). -Nonatomic is thread unsafe. -but it is fast in performance -Nonatomic is NOT default behavior,we need to add nonatomic keyword in property attribute. -it may result in unexpected behavior, when two different process (threads) access the same variable at the same time.

Example:

@property (nonatomic, retain) NSString *name;

@synthesize name;
           

Explain:

Suppose there is an atomic string property called "name", and if you call [self setName:@"A"] from thread A,  call [self setName:@"B"] from thread B, and call [self name] from thread C, then all operation on different thread will be performed serially which means if one thread is executing setter or getter, then other threads will wait. This makes property "name" read/write safe but if another thread D calls [name release] simultaneously then this operation might produce a crash because there is no setter/getter call involved here. Which means an object is read/write safe (ATOMIC) but not thread safe as another threads can simultaneously send any type of messages to the object. Developer should ensure thread safety for such objects.

If the property "name" was nonatomic, then all threads in above example - A,B, C and D will execute simultaneously producing any unpredictable result. In case of atomic, Either one of A, B or C will execute first but D can still execute in parallel.

總結： 禁止多線程，變量保護，提高性能， 指出通路器不是原子操作，而預設地，通路器是原子操作。這也就是說，在多線程環境下，解析的通路器提供一個對屬性的安全通路，從擷取器得到的傳回值或者通過設定器設定的值可以一次完成，即便是别的線程也正在對其進行通路。如果你不指定 nonatomic ，在自己管理記憶體的環境中，解析的通路器保留并自動釋放傳回的值，如果指定了 nonatomic ，那麼通路器隻是簡單地傳回這個值。

03. strong (iOS4 = retain )

-it says "keep this in the heap until I don't point to it anymore" -in other words " I'am the owner, you cannot dealloc this before aim fine with that same as retain" -You use strong only if you need to retain the object. -By default all instance variables and local variables are strong pointers. -We generally use strong for UIViewControllers (UI item's parents) -strong is used with ARC and it basically helps you , by not having to worry about the retain count of an object. ARC automatically releases it for you   when you are done with it.Using the keyword strong means that you own the object.

Example:

@property (strong, nonatomic) ViewController *viewController;

@synthesize viewController;
           

總結：任何時候，一個指針變量(poiter variable)儲存了一個對象(Object), 那麼這個對象就有了一個擁有者(owner)，且将一直保持在記憶體中。

04. weak (iOS4 = unsafe_unretained )

-it says "keep this as long as someone else points to it strongly" -the same thing as assign, no retain or release -A "weak" reference is a reference that you do not retain. -We generally use weak for IBOutlets (UIViewController's Childs).This works because the child object only   needs to exist as long as the parent object does. -a weak reference is a reference that does not protect the referenced object from collection by a garbage collector. -Weak is essentially assign, a unretained property. Except the when the object is deallocated the weak pointer is automatically set to nil

Example :

@property (weak, nonatomic) IBOutlet UIButton *myButton;

@synthesize myButton;
           

Explain:

Imagine our object is a dog, and that the dog wants to run away (be deallocated). Strong pointers are like a leash on the dog. As long as you have the leash attached to the dog, the dog will not run away. If five people attach their leash to one dog, (five strong pointers to one object), then the dog will not run away until all five leashes are detached. Weak pointers, on the other hand, are like little kids pointing at the dog and saying "Look! A dog!" As long as the dog is still on the leash, the little kids can still see the dog, and they'll still point to it. As soon as all the leashes are detached, though, the dog runs away no matter how many little kids are pointing to it. As soon as the last strong pointer (leash) no longer points to an object, the object will be deallocated, and all weak pointers will be zeroed out. When we use weak? The only time you would want to use weak, is if you wanted to avoid retain cycles  (e.g. the parent retains the child and the child retains the parent so neither is ever released).

總結：弱引用的作用是，當兩個對象隻存在互相引用，那ARC将釋放對象的記憶體使用。

05. retain = strong

-it is retained, old value is released and it is assigned - retain specifies the new value should be sent -retain on assignment and the old value sent  -release -retain is the same as strong. -apple says if you write retain it will auto converted/work like strong only. -methods like "alloc" include an implicit "retain"

Example:

@property (nonatomic, retain) NSString *name;

@synthesize name;
           

總結：對其他NSObject和其子類對參數進行release舊值，再retain新值指定retain會在指派時喚醒傳入值的retain消息。此屬性隻能用于Objective-C對象類型，而不能用于Core Foundation對象。(原因很明顯，retain會增加對象的引用計數，而基本資料類型或者Core Foundation對象都沒有引用計數——譯者注)。注意: 把對象添加到數組中時，引用計數将增加對象的引用次數+1。

06. assign 

-assign is the default and simply performs a variable assignment -assign is a property attribute that tells the compiler how to synthesize the property's setter implementation -I would use  assign for C primitive properties and  weak for weak references to Objective-C objects.

Example:

@property (nonatomic, assign) NSString *address;

@synthesize address;
           

總結：對基礎資料類型 （NSInteger，CGFloat）和C資料類型（int, float, double, char）等等。此标記說明設定器直接進行指派，這也是預設值。在使用垃圾收集的應用程式中，如果你要一個屬性使用assign，且這個類符合NSCopying協定，你就要明确指出這個标記，而不是簡單地使用預設值，否則的話，你将得到一個編譯警告。這再次向編譯器說明你确實需要指派，即使它是可拷貝的。

07. unsafe_unretained

-unsafe_unretained is an ownership qualifier that tells ARC how to insert retain/release calls -unsafe_unretained is the ARC version of assign.

Example:

@property (nonatomic, unsafe_unretained) NSString *nickName;

@synthesize nickName;
           

08. copy

- copy is required when the object is mutable. - copy specifies the new value should be sent -copy on assignment and the old value sent  -release. -copy is  like retain returns an object which you must explicitly release (e.g., in dealloc) in non-garbage collected environments. -if you use copy then you still need to release that in dealloc. -Use this if you need the value of the object as it is at this moment, and you don't want that value to reflect any changes made by other   owners of the object. You will need to release the object when you are finished with it because you are retaining the copy.

Example:

@property (nonatomic, copy) NSArray *myArray;

@synthesize myArray;
           

總結：對NSString 它指出，在指派時使用傳入值的一份拷貝。拷貝工作由copy方法執行，此屬性隻對那些實行了NSCopying協定的對象類型有效。

09. readonly

-declaring your property as  readonly you tell compiler to not generate setter method automatically. -Indicates that the property is read-only. -If you specify readonly, only a getter method is required in the  @implementation block. If you use the @synthesize directive in   the  @implementation block, only the getter method is synthesized. Moreover, if you attempt to assign a value using the dot syntax,   you get a compiler error.

Example:

@property (nonatomic, readonly) NSString *name;

@synthesize name;
           

10. readwrite 

-setter and getter generated. -Indicates that the property should be treated as read/write. -This attribute is the default. -Both a getter and setter method are required in the @implementation block. If you use the @synthesize directive in the implementation   block, the getter and setter methods are synthesized.

Example:

@property (nonatomic, readwrite) NSString *name;

@synthesize name;
           

文章來自：stackoverflow