在iOS开发中定义@property属性时，经常用到assign、weak、strong、copy等关键字。我们经常会考虑在何时应该使用哪个关键字，尤其是在面试的时候，经常会被问到这些关键字之间的区别。

1.首先我们需要明确，对象的内存一般被分配到堆上，基本数据类型和OC数据类型一般被分配在栈上。
2.栈上内存由系统分配和释放，堆上内存由程序员手动释放

weak

weak：修饰Object类型，修饰的对象在释放后，指针地址会被置为nil，是一种弱引用。
在ARC环境下，为避免循环引用，往往会把delegate属性用weak修饰；在MRC下使用assign修饰。
weak和strong不同的是：当一个对象不再有strong类型的指针指向它的时候，它就会被释放，即使还有weak型指针指向它，那么这些weak型指针也将被清除。

weak释放为nil过程

weak被释放为nil，需要对对象整个释放过程了解，如下是对象释放的整体流程：
1、调用objc_release
2、因为对象的引用计数为0，所以执行dealloc
3、在dealloc中，调用了_objc_rootDealloc函数
4、在_objc_rootDealloc中，调用了object_dispose函数
5、调用objc_destructInstance
6、最后调用objc_clear_deallocating。

对象准备释放时，调用clearDeallocating函数。clearDeallocating函数首先根据对象地址获取所有weak指针地址的数组，然后遍历这个数组把其中的数据设为nil，最后把这个entry从weak表中删除，最后清理对象的记录。

objc_clear_deallocating该函数的动作如下：

1、从weak表中获取废弃对象的地址为键值的记录
2、将包含在记录中的所有附有 weak修饰符变量的地址，赋值为nil
3、将weak表中该记录删除
4、从引用计数表中删除废弃对象的地址为键值的记录

rntime维护了一个hash(哈希)表，用于存储指向某个对象的所有weak指针。weak表其实是一个hash（哈希）表，Key是所指对象的地址，Value是weak指针的地址（这个地址的值是所指对象指针的地址）数组。

assign

assign：用于对基本数据类型进行赋值操作，不更改引用计数。
也可以用来修饰对象，但是，被assign修饰的对象在释放后，指针的地址还是存在的，也就是说指针并没有被置为nil，成为野指针。如果后续在分配对象到堆上的某块内存时，正好分到这块地址，程序就会crash。之所以可以修饰基本数据类型，因为基本数据类型一般分配在栈上，栈的内存会由系统自动处理，不会造成野指针。

1.1 使用assign修饰基本数据类型

assign修饰基本数据类型或OC数据类型，因为基本数据类型是分配在栈上的，由系统分配和释放，所以不会造成野指针。

1.2 使用assign修饰对象

如果用assign修饰对象，当对象释放后（因为不存在强引用，离开作用域对象内存可能被回收），指针的地址还是存在的，也就是说指针并没有被置为nil,下次再访问该对象就会造成野指针异常。 【对象是分配在堆上的，堆上的内存由程序员手动释放。】

strong

strong：强引用，我们在用strong 修饰属性的时候，我们可以理解为 是对对象的 直接引用。
类似于，我有一个苹果，你想用我的苹果，我把我的苹果交到你的手里，然后你把苹果咬了一口，其实那是我的苹果被咬了一口，你还我的时候，我的苹果已经不完整了。
也就是说我们用 strong 修饰的属性，无论我们在哪里改动他了，改变的都是最初的他。（利用这个特性我们可以做很多事，尤其是跨多个页面刷新本地缓存的功能）
strong声明后的对象会更改引用计数，那么每次被引用，引用计数都会+1，释放后就会-1，即使这个对象本身释放了，只要还有对象在引用它，就会持有，不会造成什么问题，只有当引用计数为0时，就被dealloc析构函数回收内存了。

• 如果不是通过属性来初始化一个对象的话，系统默认帮我们加了_strong修饰来进行内存管理，就是这种情况

 NSMutableArray *firstArray = [NSMutableArray array];

那么strong修饰的对象什么时候会被释放呢？

• 当对象的引用计数为0的时候，该strong对象会被释放
• 当strong修饰的属性对象，持有该属性对象的对象被释放的时候，通过dealloc方法，会释放掉所有强引用的对象（也就是说被持有的对象）

那么strong修饰的对象是怎么保存新值，释放旧值的？

- (void)setName:(NSString *)name
{
    [name retain];
    [_name release];
    _name = name;
}

copy

copy：会在内存里拷贝一份对象，两个指针指向不同的内存地址。一般用来修饰NSString等有对应可变类型的对象，因为他们有可能和对应的可变类型（NSMutableString）之间进行赋值操作，为确保可变对象变化时，对象中的字符串不被修改 ，应该在设置属性时拷贝一份。而若用strong修饰，如果可变对象变化，对象中的字符串属性也会跟着变化。

扩展

1.深拷贝，浅拷贝

• [NSArray copy] 浅拷贝
  内存地址不变 还是那个对象 不可变类型 NSArray

• [NSArray mutableCopy] 深拷贝
  内存地址改变 得到新的对象 可变类型 NSMutableArray

• [NSMutableArray copy] 深拷贝
  内存地址改变 得到新的对象 不可变类型 NSArray

• [NSMutableArray mutableCopy] 深拷贝
  内存地址改变 得到新的对象 可变类型 NSMutableArray

拷贝的目的：产生一个新的副本对象，跟原对象互不影响；

2. 修饰可变对象与不可变对象用strong，还是copy？使用copy修饰NSMutableArray会怎样？使用strong修饰NSArray会怎样？

• 当修饰可变类型的属性时，如NSMutableArray、NSMutableDictionary、NSMutableString，用strong。

• 当修饰不可变类型的属性时，如NSArray、NSDictionary、NSString，用copy。

• NSMutableArray用copy修饰有时就会crash，因为对这个数组进行了增删改操作，而copy后的数组变成了不可变数组NSArray，没有响应的增删改方法，所以对其进行增删改操作就会报错。

http://blog.csdn.net/winzlee/article/details/51752354

• NSArray用strong修饰,数组的内容会发生改变，这可能会意外导致bug的产生。

@property(strong,nonatomic)NSArray * arry1;
@property(copy,nonatomic)NSArray * arry2;

    NSMutableArray * muArry = [NSMutableArray arrayWithArray:@[@1]];
    self.arry1 = muArry;
    self.arry2 = muArry;

    NSLog(@"muArry 地址： %p  ---  %@", muArry,[muArry class]);
    NSLog(@"arry1 地址： %p  ---  %@", self.arry1 ,[self.arry1  class]);
    NSLog(@"arry2 地址： %p  ---  %@", self.arry2 ,[self.arry2  class]);

    NSLog(@"strong修饰NSArray --- %@ --- copy修饰NSArray --- %@",self.arry1,self.arry2);
    [muArry addObject:@2];
    NSLog(@"strong修饰NSArray --- %@ --- copy修饰NSArray --- %@",self.arry1,self.arry2);

打印：
muArry 地址： 0x6000031e62b0  ---  __NSArrayM
arry1 地址： 0x6000031e62b0  ---  __NSArrayM
arry2 地址： 0x600003d8cf60  ---  __NSSingleObjectArrayI

strong修饰NSArray --- (
    1
) --- copy修饰NSArray --- (
    1
)
strong修饰NSArray --- (
    1,
    2
) --- copy修饰NSArray --- (
    1
)

被strong修饰之后，由于只是强引用，所以副本对象数组和源对象数组只是指向同一个内存区域，这样就会造成副本对象数组会随着源对象数组的改变而改变
被copy修饰之后，源对象数组被copy了一份，源对象数组和副本对象数组是不同的，所以副本对象数组并不会随着源对象数组改变。

3.block属性为什么需要用copy来修饰？

因为在MRC下，block在创建的时候，它的内存是分配在栈(stack)上的，而不是在堆(heap)上，可能被随时回收。他本身的作于域是属于创建时候的作用域，一旦在创建时候的作用域外面调用block将导致程序崩溃。通过copy可以把block拷贝（copy）到堆，保证block的声明域外使用。在ARC下写不写都行，编译器会自动对block进行copy操作。

__block与__weak的区别

__block：在ARC和MRC下都可用，可修饰对象，也可以修饰基本数据类型。

__block对象可以在block被重新赋值，__weak不可以。

__weak：只在ARC中使用，只能修饰对象，不能修饰基本数据类型（int、bool）。
同时，在ARC下，要避免block出现循环引用，经常会：__weak typedof(self) weakSelf = self;

atomic

• 是默认的
• 对同一对象的set和get的操作是顺序执行的
• 速度不快，因为要保证操作整体完成
• 线程安全，需要消耗大量系统资源来为属性加锁
  使用atomic并不能保证绝对的线程安全，对于要绝对保证线程安全的操作，还需要使用更高级的方式来处理，比如NSSpinLock、@syncronized等

nonatomic

• 不是默认的
• 更快
• 如有两个线程访问同一个属性，会出现无法预料的结果
• 非线程安全，适合内存较小的移动设备

在不添加atomic或nonatomic的情况下，默认的是atomic

解释

atomic修饰的属性,系统生成的 getter/setter 会保证 get、set 操作的完整性，不受其他线程影响。比如，线程 A 的 getter 方法运行到一半，线程 B 调用了 setter：那么线程 A 的 getter 还是能得到一个完好无损的对象。

nonatomic修饰的属性,不做保持getter完整性保证，但在运行速度上要比atomic快

快速理解

假设有一个 atomic 的属性 "name"，如果线程 A 调[self setName:@"A"]，线程 B 调[self setName:@"B"]，线程 C 调[self name]，那么所有这些不同线程上的操作都将依次顺序执行——也就是说，如果一个线程正在执行 getter/setter，其他线程就得等待。因此，属性 name 是读/写安全的。

但是，如果有另一个线程 D 同时在调[name release]，那可能就会crash，因为 release 不受 getter/setter 操作的限制。也就是说，这个属性只能说是读/写安全的，但并不是线程安全的，因为别的线程还能进行读写之外的其他操作。线程安全需要开发者自己来保证。

如果 name 属性是 nonatomic 的，那么上面例子里的所有线程 A、B、C、D 都可以同时执行，可能导致无法预料的结果。如果是 atomic 的，那么 A、B、C 会串行，而 D 还是并行的。

简单来说，就是 atomic 会加一个锁来基本保障线程安全（但不能保证线程安全），并且引用计数会 +1，来向调用者保证这个对象会一直存在。假如不这样做，如有另一个线程调 setter，可能会出现线程竞态，导致引用计数降到0，原来那个对象就释放掉了。

参考：
https://www.jianshu.com/p/f331bd5ce8f8
https://www.jianshu.com/p/8dd0705dc586?utm_source=desktop&utm_medium=timeline
https://www.jianshu.com/p/709d8638108e
https://www.jianshu.com/p/9cb898db8a63
https://www.jianshu.com/p/0c4b6d7e5fde
https://www.jianshu.com/p/bd4cc82e09c5
https://blog.csdn.net/qq_27909209/article/details/82689322