一、@property参数

1、第一组
内存管理特性：retain assign copy strong weak unsafe_unretained autoreleasing

2、第二组
读 /写特性：readwrite readonly

3、第三组
多线程特性：nonatomic atomic

4、第四组
方法名特性：setter getter

二、参数作用

1、第一组（retain assign copy strong weak unsafe_unretained autoreleasing）用于：set方法内存管理

assign（默认参数）：setter方法直接赋值，不进行任何retain操作，不改变引用计数。该方法只会针对“纯量类型”(CGFloat或NSInteger等)和C数据类型（int, float, double, char, 等等）的简单赋值操作，id类型也要用assign，所以一般iOS中的代理delegate属性都会用assign来标示。

retain：生成符合内存管理的set方法（release旧值，retain新值），适用于OC对象的成员变量。

copy：生成符合内存管理的set方法（release旧值，copy新值），适用于NSString、NSArray等不可变对象。和strong类似，不过该属性会被复制一个新的副本。很多时候使用copy是为了防止Mutable（可变类型）在我们不知道的情况下修改了属性值，而用copy可以生成一个不可变的副本防止被修改。如果我们自己实现setter方法的话，需要手动copy。

strong：强引用，其存亡直接决定了所指向对象的存亡。使用该特性实例变量在赋值时，会释放旧值同时设置新值，对对象产生一个强引用，即引用计数+1。如果不存在指向一个对象的引用，并且此对象不再显示在列表中，则此对象会被从内存中释放。适用于一般OC对象。

weak：表示的是一个弱引用，这个引用不会增加对象的引用计数，并且在所指向的对象被释放之后，weak指针会被置为nil。weak引用通常是用于处理循环引用的问题，如代理及block的使用中，相对会较多的使用到weak。即使一个对象被持有无数个弱引用，只要没有强引用指向它，那么还是会被清除。相比于assign，声明为weak的指针，指针指向的地址一旦被释放，这些指针都将被赋值为 nil。这样的好处能有效的防止野指针。因为ViewController对控件强引用，如果delegate声明为strong，UI控件代理一般指向ViewController本身，那么就会造成循环引用。不过非UI控件的delegate的属性声明是weak还是strong就要视情况而定。一般iOS的ARC中的代理delegate属性都会用weak，有时候也用于UI控件(如果是懒加载则必须用strong)。

UI控件到底用weak还是strong？

1、从storyboard或者xib上创建控件，在控件放在view上的时候，已经形成了如下的引用关系,以UIButton为例：
UIViewController->UIView->subView->UIButton
然后你为这个UIButton声明一个weak属性

@property(nonatomic,weak) IBOOutlet UIButton *btn;

相当于xib/sb对这个Button是强引用，你声明的属性对它是弱引用。

2、代码创建控件
（a）将控件声明成strong

@property(nonatomic,strong) UIButton *btn;

那么你在实现这个控件时只需这样：

_btn = [[UIButton alloc]init];
[self.view addSubview:_btn]

（b）将控件声明成weak

@property(nonatomic,weak) UIButton *btn

那么你在实现这个控件时需要这样：

UIButton *button = [[UIButton alloc]init];
_btn = button;
[self.view addSubview:_btn];

Delegate到底用weak还是assign？

为了在 Delegate 关系中防止强引用循环。在 ARC 特性下，通常我们应该设置 Delegate 属性为 weak 的。但是这里有一个疑问，我们常用到的 UITableView 的 delegate 属性是这样定义的： @property (nonatomic, assign) id<UITableViewDelegate> delegate;，为什么用的修饰符是 assign 而不是 weak？其实这个 assign 在 ARC 中意义等同于 __unsafe_unretaied（后面会讲到），它是为了在 ARC 特性下兼容 iOS4 及更低版本来实现弱引用机制。一般情况下，你应该尽量使用 weak。

unsafe_unretained：和weak一样，唯一的区别就是当对象被释放后，该属性不会被设置为nil，当该对象指针指向的内存地址被释放后，如果我们没有将其设置为nil，则在调用时会造成野指针，因为指向的内存释放了，所以是unsafe的，访问野指针的内存就造成crash，所以尽量少用。

注意：

（1）weak与Strong一般在开启ARC机制下使用

（2）Strong决定了对象的存亡（一个对象如果没有强指针指向（引用计数器为0）时，对象将被销毁，释放内存），其指向一个对象，相当于该对象做了一次retain操作。

非ARC的retain，相当于ARC的strong，ARC的弱引用weak相当于非ARC的assign

使用copy参数与使用retain参数产生的set方法一致（将生成set方法中的retain改为copy即可）

strong,weak, unsafe_unretained往往都是用来声明属性的，如果想声明临时变量就得用__strong, __weak, __unsafe_unretained, __autoreleasing, 其用法与上面介绍的类似。

例如：

__strong NSString *yourString = @"Your String";

__weak NSString *myString = yourString;

yourString = nil;

__unsafe_unretained NSString *theirString = myString;

//现在所有的指针都为nil

再例如：

__strong NSString *yourString = @"Your String";
 
__weak NSString *myString = yourString;
 
__unsafe_unretained NSString *theirString = myString;
 
yourString = nil;
 
//现在yourString与myString的指针都为nil,而theirString不为nil,但是是野指针。

__autoreleasing：在c/c++，objective-c内存管理中有一条是：谁分配谁释放。 __autoreleasing则可以使对像延迟释放。比如你想传一个未初始化地对像引用到一个方法当中，在此方法中实例化此对像，那么这种情况将是__autoreleasing表演的时候。例如：

- (void)generateErrorInVariable:(__autoreleasing NSError **)paramError 
{
    NSArray *objects = [[NSArray alloc] initWithObjects:@"A simple error", nil];
 
    NSArray *keys = [[NSArray alloc] initWithObjects:NSLocalizedDescriptionKey, nil];

    NSDictionary *errorDictionary = [[NSDictionary alloc] initWithObjects:objects forKeys:keys];

    *paramError = [[NSError alloc] initWithDomain:@"MyApp"code:1 userInfo:errorDictionary];
}

- (void)test 
{
    NSError *error = nil;

    [self generateErrorInVariable:&error];
    NSLog(@"Error = %@", error);
}

这样即便在函数内部申请的空间，在函数外部也可以使用，同样也适合谁分配谁释放的原则。

同样下面的代码也是类似原因, 只不过在没有开启ARC的情况下适用：

-(NSString *)stringTest
 
{
 
    NSString *retStr = [NSString stringWithString:@"test"];
 
    return[[retStr retain] autorelease];
 
}

开启ARC后，应改为：

- (NSString *)stringTest
{
    __autoreleasing NSString *retStr = [NSString alloc] initWithString:@"test"];

    return retStr;
}

2、第二组（readwrite readonly）用于：是否要生成set方法

readwrite（默认参数）：同时生成set、get方法的声明与实现，可读、可写

readonly：只生成get方法的声明与实现（不生成set的方法的声明与实现），只读

3、第三组（nonatomic atomic）用于：多线程管理

atomic（默认参数）：原子性，性能低（一般开发OC中的APP不推荐使用，做金融等要求高安全的时候使用）

nonatomic：非原子性，性能高（强烈推荐使用，性能高）

atomic：（原子性操作），会被加锁，就是一个操作执行过程不能被中断,要不就执行完,要不就不执行（一个操作不可以在中途被cpu暂停然后调度）。如果一个操作是原子性的,那么在多线程环境下,就不会出现变量被修改等奇怪的问题（保证数据同步）。原子操作就是不可再分的操作，在多线程程序中原子操作是一个非常重要的概念，它常常用来实现一些同步机制，同时也是一些常见的多线程Bug的源头。

nonatomic：（非原子性操作）操作是直接从内存中取数值（不考虑其是否被占用），因为它是从内存中取得数据，它并没有一个加锁的保护来用于cpu中的寄存器计算Value，它只是单纯的从内存地址中，当前的内存存储的数据结果来进行使用。在多线程环境下可提高性能，但无法保证数据同步。

4、第四组（setter getter）用于：set、get方法重命名（常用于BOOL类型的成员变量的get方法,BOOL方法常以is开头（set方法很少用））

setter：给成员变量的set方法重命名，set方法默认命名：- （void） set成员变量名（成员变量名首字母大写）：（成员变量数据类型）成员变量名。

getter：给成员变量的set方法重命名，get方法默认命名：- （成员变量数据类型）成员变量名。
synthesize ：合成访问器方法，实现property所声明的方法的定义。其实说直白就像是：property声明了一些成员变量的访问方法，synthesize则定义了由property声明的方法。

他们之前的对应关系是:property 声明方法 ->头文件中申明getter和setter方法 synthesize定义方法 -> m文件中实现getter和setter方法。在.m文件中同时实现getter和setter时候需要@synthesize age = _age。

在Xcode4.5及以后的版本中，可以省略@synthesize，编译器会自动帮你加上get 和 set 方法的实现，并且默认会去访问_age这个成员变量，如果找不到_age这个成员变量，会自动生成一个叫做 _age的私有成员变量。

注意：@property (nonatomic) NSString *name; 在arc下，默认是strong。但是如果是bool等基本数据类型默认就是assign

所以property的属性默认是：readwrite，assign/strong , atomic

@property探究(二): 深入理解

在进入正题之前，先介绍一个clang编译器的命令

clang -rewrite-objc main.m 
这个命令用于clang重写.m文件为.cpp文件。

@property深入代码理解

我们都知道

@property = ivar + getter + setter

ivar就是实例变量，编译器会帮我们自动生成名字为'_属性名'这样的实例变量，同时也会自动生成getter和setter方法。

有如下代码

#import <Foundation/Foundation.h>

@interface Person : NSObject

@property (nonatomic, copy) NSString* cjmName;
@property (nonatomic, assign) NSUInteger cjmAge;

@end

@implementation Person

@synthesize cjmName = _cjmName;
@synthesize cjmAge = _cjmAge;

@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Person *p = [[Person alloc] init];
        p.cjmName = @"JIaming Chen";
        p.cjmAge = 22;
    }
    return 0;
}

使用上述命令后生成的.cpp文件中可以查找到如下部分的代码

#ifndef _REWRITER_typedef_Person
#define _REWRITER_typedef_Person
typedef struct objc_object Person;
typedef struct {} _objc_exc_Person;
#endif

extern "C" unsigned long OBJC_IVAR_$_Person$_cjmName;
extern "C" unsigned long OBJC_IVAR_$_Person$_cjmAge;
struct Person_IMPL {
        struct NSObject_IMPL NSObject_IVARS;
        NSString *_cjmName;
        NSUInteger _cjmAge;
};


// @property (nonatomic, copy) NSString* cjmName;
// @property (nonatomic, assign) NSUInteger cjmAge;

/* @end */


// @implementation Person

// @synthesize cjmName = _cjmName;
static NSString * _I_Person_cjmName(Person * self, SEL _cmd) { return (*(NSString **)((char *)self + OBJC_IVAR_$_Person$_cjmName)); }
extern "C" __declspec(dllimport) void objc_setProperty (id, SEL, long, id, bool, bool);

static void _I_Person_setCjmName_(Person * self, SEL _cmd, NSString *cjmName) { objc_setProperty (self, _cmd, __OFFSETOFIVAR__(struct Person, _cjmName), (id)cjmName, 0, 1); }

// @synthesize cjmAge = _cjmAge;
static NSUInteger _I_Person_cjmAge(Person * self, SEL _cmd) { return (*(NSUInteger *)((char *)self + OBJC_IVAR_$_Person$_cjmAge)); }
static void _I_Person_setCjmAge_(Person * self, SEL _cmd, NSUInteger cjmAge) { (*(NSUInteger *)((char *)self + OBJC_IVAR_$_Person$_cjmAge)) = cjmAge; }


// @end


int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
        Person *p = ((Person *(*)(id, SEL))(void *)objc_msgSend)((id)((Person *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("Person"), sel_registerName("alloc")), sel_registerName("init"));
        ((void (*)(id, SEL, NSString *))(void *)objc_msgSend)((id)p, sel_registerName("setCjmName:"), (NSString *)&__NSConstantStringImpl__var_folders_1f_dz4kq57d4b19s4tfmds1mysh0000gn_T_main_4b2631_mi_0);
        ((void (*)(id, SEL, NSUInteger))(void *)objc_msgSend)((id)p, sel_registerName("setCjmAge:"), (NSUInteger)22);
    }
    return 0;
}

以上代码就是编译器为我们生成的C代码，现在一一讲解几个比较重要的部分。

typedef struct objc_object Person;

编译器将struct objc_object重命名为我们自定义的Person类，struct objc_object结构体只有一个类型为Class的isa指针变量

/// Represents an instance of a class.
struct objc_object {
    Class isa  OBJC_ISA_AVAILABILITY;
};

而这个Class就代表类对象。

/// An opaque type that represents an Objective-C class.
typedef struct objc_class *Class;

struct objc_class {
    Class isa  OBJC_ISA_AVAILABILITY;

/#if !__OBJC2__
    Class super_class                                        OBJC2_UNAVAILABLE;
    const char *name                                         OBJC2_UNAVAILABLE;
    long version                                             OBJC2_UNAVAILABLE;
    long info                                                OBJC2_UNAVAILABLE;
    long instance_size                                       OBJC2_UNAVAILABLE;
    struct objc_ivar_list *ivars                             OBJC2_UNAVAILABLE;
    struct objc_method_list **methodLists                    OBJC2_UNAVAILABLE;
    struct objc_cache *cache                                 OBJC2_UNAVAILABLE;
    struct objc_protocol_list *protocols                     OBJC2_UNAVAILABLE;
#endif

} OBJC2_UNAVAILABLE;

（由于篇幅问题，本文不详细讲解OC类的实现细节，如有兴趣可以参考iOS 深入代码理解类对象）你只需要知道这个Person就是我们创建的类对象就好了，这个类对象包含了Person类所需的所有东西，包括属性、方法列表、版本号等一系列信息。

接下来的

extern "C" unsigned long OBJC_IVAR_$_Person$_cjmName;
extern "C" unsigned long OBJC_IVAR_$_Person$_cjmAge;

定义了两个unsigned long类型的变量，这两个变量代表一个偏移量，值这两个实例变量在内存中存储的偏移量，通过这两个值就能够在内存中定位到这两个实例变量的位置。
这两个值是运行时计算出偏移量硬编码(hard code)写入的，这样的好处在于，如果你使用了一个库，这个库的类定义比较旧，而链接的代码使用的是版本较新的代码，增加了几个实例变量，你的程序运行时也不会报错，因为偏移量是通过运行时计算出来的，仍旧能够找到相应的位置。如果不使用合成存取方法定义实例变量而使用手工的方式创建，这个偏移量就是编译器计算出硬编码写到代码中的，如果类定义和链接库的版本不一致则可能发生指针错误，因此鼓励大家尽量都使用合成存取方法。

struct Person_IMPL {
        struct NSObject_IMPL NSObject_IVARS;
        NSString *_cjmName;
        NSUInteger _cjmAge;
};

该结构体就是Person类实现，struct NSObject_IMPL结构体只有一个Class isa结构体指针变量，指向类对象，用于获取Person类的方法列表、实例变量列表、属性列表、版本等信息。可以看出，在底层代码中编译器帮我们自动生成了名为_cjmName和_cjmAge的两个实例变量，如果我们修改@synthesize cjmName = _cjmName为其他名称则这列会生成相应名称的实例变量。

static NSString * _I_Person_cjmName(Person * self, SEL _cmd) { return (*(NSString **)((char *)self + OBJC_IVAR_$_Person$_cjmName)); }

这句代码就是属性cjmName的getter方法，可以看出，使用了OBJC_IVAR_$_Person$_cjmName偏移量来计算实例变量的存储位置并返回。

extern "C" __declspec(dllimport) void objc_setProperty (id, SEL, long, id, bool, bool); static void _I_Person_setCjmName_(Person * self, SEL _cmd, NSString *cjmName) { objc_setProperty (self, _cmd, __OFFSETOFIVAR__(struct Person, _cjmName), (id)cjmName, 0, 1); }

这两句代码是属性cjmName的setter方法，使用__OFFSETOFIVAR__(TYPE, MEMBER)宏定义来计算偏移量，上文指的偏移量都是通过该宏定义计算而来，计算出偏移量后使用objc_setProperty来设置实例变量_cjmName的值。
将属性cjmName的修饰符改为strong后再次查看重写的setter代码:

static void _I_Person_setCjmName_(Person * self, SEL _cmd, NSString *cjmName) { 
    (*(NSString **)((char *)self + OBJC_IVAR_$_Person$_cjmName)) = cjmName; 
}

与上文代码相比发现，没有声明objc_setProperty方法也没有使用该方法，而是直接计算出实例变量的偏移量后将指针赋给实例变量。由此就可以看出修饰符copy和strong底层代码的区别。

同样的可以将修饰符改为assign、unsafe_unretained、weak来查看生成的代码，结果都同Strong一致，这就解释了底层代码是如何copy实例变量的。

再来看看以下几个结构体:

struct _ivar_t {
        unsigned long int *offset;  // pointer to ivar offset location
        const char *name;
        const char *type;
        unsigned int alignment;
        unsigned int  size;
};

static struct /*_ivar_list_t*/ {
        unsigned int entsize;  // sizeof(struct _prop_t)
        unsigned int count;
        struct _ivar_t ivar_list[2];
} _OBJC_$_INSTANCE_VARIABLES_Person __attribute__ ((used, section ("__DATA,__objc_const"))) = {
        sizeof(_ivar_t),
        2,
        {{(unsigned long int *)&OBJC_IVAR_$_Person$_cjmName, "_cjmName", "@\"NSString\"", 3, 8},
         {(unsigned long int *)&OBJC_IVAR_$_Person$_cjmAge, "_cjmAge", "Q", 3, 8}}
};

struct _ivar_t结构体表示每一个实例变量，记录了偏移值、名称、类型、对齐方式和大小，用于描述每一个实例变量。
struct _ivar_list_t结构体表示类的实例变量列表，记录了实例变量的大小、个数、以及每一个实例变量描述。
我们每在类中加入一个属性，编译器都会在_ivar_list_t变量中加入一个_ivar_t的实例变量描述。

struct _objc_method {
        struct objc_selector * _cmd;
        const char *method_type;
        void  *_imp;
};

static struct /*_method_list_t*/ {
        unsigned int entsize;  // sizeof(struct _objc_method)
        unsigned int method_count;
        struct _objc_method method_list[4];
} _OBJC_$_INSTANCE_METHODS_Person __attribute__ ((used, section ("__DATA,__objc_const"))) = {
        sizeof(_objc_method),
        4,
        {{(struct objc_selector *)"cjmName", "@16@0:8", (void *)_I_Person_cjmName},
        {(struct objc_selector *)"setCjmName:", "v24@0:8@16", (void *)_I_Person_setCjmName_},
        {(struct objc_selector *)"cjmAge", "Q16@0:8", (void *)_I_Person_cjmAge},
        {(struct objc_selector *)"setCjmAge:", "v24@0:8Q16", (void *)_I_Person_setCjmAge_}}
};

struct _objc_method结构体描述了每一个实例方法，包括一个SEL类型的指针、方法类型和方法实现。
struct _method_list_t结构体表示类的实例方法列表，记录了每一个实例方法的大小、实例方法个数以及具体的实例方法描述，每加入一个属性则会在_method_list_t中增加setter与getter方法的描述。

struct _prop_t {
        const char *name;
        const char *attributes;
};

static struct /*_prop_list_t*/ {
        unsigned int entsize;  // sizeof(struct _prop_t)
        unsigned int count_of_properties;
        struct _prop_t prop_list[2];
} _OBJC_$_PROP_LIST_Person __attribute__ ((used, section ("__DATA,__objc_const"))) = {
        sizeof(_prop_t),
        2,
        {{"cjmName","T@\"NSString\",C,N,V_cjmName"},
        {"cjmAge","TQ,N,V_cjmAge"}}
};

struct _prop_t结构体描述了每一个属性，包括名称和属性值。
struct _prop_list_t结构体表示属性列表，记录了每一个属性的大小、属性个数以及具体的属性描述，每加入一个属性则会在_prop_list_t中增加_prop_t属性描述。
从结构体中的值不难看出，属性描述中的T@表示是类型对象后接类型名称，C表示copy，N表示nonatomic，V_cjmName表示实例变量。

总结

通过上述代码我们可以看出编译器对@property的处理方法，以及几种修饰符的实现方式。也能够对其有一个更深入的理解。

@dynamic与@synthesize

一、@dynamic与@synthesize的区别

首先@表示当前使用的OC代码。

@property有两个对应的词，一个是@synthesize，一个是@dynamic。如果@synthesize和@dynamic都没写，那么默认的就是@syntheszie var = _var;

@synthesize的语义是如果你没有手动实现setter方法和getter方法，那么在编译的时候编译器会自动为你加上这两个方法。

@dynamic告诉编译器,属性的setter与getter方法由用户自己实现，不自动生成。（当然对于readonly的属性只需提供getter即可）。假如一个属性被声明为@dynamic var，然后你没有提供@setter方法和@getter方法，编译的时候没问题，但是当程序运行到instance.var =someVar，由于缺setter方法会导致程序崩溃；或者当运行到 someVar = var时，由于缺getter方法同样会导致崩溃。编译时没问题，运行时才执行相应的方法，这就是所谓的动态绑定。

用@dynamic后，可以在存取方法中访问一个私有变量来赋值或取值。而@synthesize则直接用@synthesize var = _var；来让属性和私有变量直接等同起来。这就是二者在书写形式上的差别。

@dynamic最常用的使用是在NSManagedObject中，此时不需要显示编程setter和getter方法。原因是：@dynamic告诉编译器不做处理，使编译通过，其getter和setter方法会在运行时动态创建，由Core Data框架为此类属性生成存取方法。

nonatomic和atomic的区别？atomic是绝对的线程安全么？为什么？如果不是，那应该如何实现？

原文@property参数、@property探究(二): 深入理解、@dynamic与@synthesize的区别

iOS Property参数