Objective-C declared @property attributes (nonatomic, copy, strong, weak)

Can someone explain to me in detail when I must use each attribute: `nonatomic`, `copy`, `strong`, `weak`, and so on, for a declared property, and explain what each does? Some sort of example would be great also. I am using ARC.

This link has the break down

[

[To see links please register here]

][1]

> assign implies __unsafe_unretained ownership.
>
> copy implies __strong ownership, as well as the usual behavior of copy
> semantics on the setter.
>
> retain implies __strong ownership.
>
> strong implies __strong ownership.
>
> unsafe_unretained implies __unsafe_unretained ownership.
>
> weak implies __weak ownership.


[1]:

[To see links please register here]

Great answers!
One thing that I would like to clarify deeper is `nonatomic`/`atomic`.
The user should understand that this property - "atomicity" spreads only on the attribute's reference and not on it's contents.
I.e. `atomic` will guarantee the user atomicity for reading/setting the pointer and only the pointer to the attribute.
For example:

@interface MyClass: NSObject
@property (atomic, strong) NSDictionary *dict;
...

In this case it is guaranteed that the pointer to the `dict` will be read/set in the atomic manner by different threads.
BUT the `dict` itself (the dictionary `dict` pointing to) is still **thread unsafe**, i.e. all read/add operations to the dictionary are still thread unsafe.

If you need thread safe collection you either have bad architecture (more often) OR real requirement (more rare).
If it is "real requirement" - you should either find good&tested thread safe collection component OR be prepared for trials and tribulations writing your own one.
It latter case look at "lock-free", "wait-free" paradigms. Looks like rocket-science at a first glance, but could help you achieving fantastic performance in comparison to "usual locking".

`nonatomic` property means `@synthesize`d methods [are __not going to be generated threadsafe__](

[To see links please register here]

) -- but this is much faster than the `atomic` property since extra checks are eliminated.

`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.

`weak` ownership means that you don't own it and it just keeps track of the object till the object it was assigned to stays , as soon as the second object is released it loses is value. For eg. `obj.a=objectB;` is used and a has weak property , than its value will only be valid till objectB remains in memory.

`copy` property is very well [explained here][1]

`strong,weak,retain,copy,assign` are mutually exclusive so you can't use them on one single object... read the ["Declared Properties "][1] section

[1]:

[To see links please register here]

[2]:http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/ObjectiveC/Chapters/ocProperties.html#//apple_ref/doc/uid/TP30001163-CH17-SW1

hoping this helps you out a bit...

## Nonatomic

[**`Nonatomic`**](

[To see links please register here]

) will ___not___ generate threadsafe routines thru `@synthesize` accessors. `atomic` will generate threadsafe accessors so `atomic` variables are threadsafe (can be accessed from multiple threads without botching of data)

## Copy

`copy` is required when the object is mutable. 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.

## Assign

`Assign` is somewhat the opposite to `copy`. When calling the getter of an `assign` property, it returns a reference to the actual data. Typically you use this attribute when you have a property of primitive type (float, int, BOOL...)

## Retain

`retain` is required when the attribute is a pointer to a reference counted object that was allocated on the heap. Allocation should look something like:

NSObject* obj = [[NSObject alloc] init]; // ref counted var

The setter generated by `@synthesize` will add a reference count to the object when it is copied so the underlying object is not autodestroyed if the original copy goes out of scope.

You will need to release the object when you are finished with it. `@property`s using `retain` will increase the reference count and occupy memory in the autorelease pool.

## Strong

`strong` is a replacement for the retain attribute, as part of Objective-C Automated Reference Counting (ARC). In non-ARC code it's just a synonym for retain.


This is a good website to learn about `strong` and `weak` for iOS 5.
[

[To see links please register here]

][1]

**Weak**

`weak` is similar to `strong` except that it won't increase the reference count by 1. It does not become an owner of that object but just holds a reference to it. If the object's reference count drops to 0, even though you may still be pointing to it here, it will be deallocated from memory.

The above link contain both Good information regarding **Weak and Strong.**

[1]:

[To see links please register here]