在知道他们区别之前，我们首先要知道NSObject对象的赋值操作做了哪些操作。
A=C其实是在内存中创建了一个A，然后又开辟了一个内存C，C里面存放的着值B

image.png

如下：

NSMutableString *tempMStr = [[NSMutableString alloc]initWithString:@"strValue"];
    NSLog(@"tempMStr值地址:%p，tempMStr值%@,tempMStr值引用计数%@\\n", tempMStr,tempMStr,[tempMStr valueForKey:@"retainCount"]);
    //tempMStr值地址:0x6000007b8420，tempMStr值strValue,tempMStr值引用计数1

此处tempMStr就是A，值地址就是C，“strValue”就是B，而引用计数这个概念是针对C的，赋值给其他变量或者指针设置为nil，如tempStr = nil，都会使得引用计数有所增减。当内存区域引用计数为0时就会将数据抹除。而我们使用copy,strong,retain,weak,assign区别就在：

1.是否开辟新的内存

2.是否对地址C(值地址)有引用计数增加

需要注意的是property修饰符是在被赋值时起作用。

1.以典型的NSMutableString为例

NSMutableString*mstrOrigin = [[NSMutableString alloc]initWithString:@"mstrOriginValue"];
    self.aCopyMStr= mstrOrigin;
    self.strongMStr= mstrOrigin;
    self.weakMStr= mstrOrigin;

    NSLog(@"mstrOrigin输出:%p,%@\\n", mstrOrigin,mstrOrigin);
    NSLog(@"aCopyMStr输出:%p,%@\\n",_aCopyMStr,_aCopyMStr);
    NSLog(@"strongMStr输出:%p,%@\\n",_strongMStr,_strongMStr);
    NSLog(@"weakMStr输出:%p,%@\\n",_weakMStr,_weakMStr);
    NSLog(@"引用计数%@",[mstrOrigin valueForKey:@"retainCount"]);
    // mstrOrigin输出:0x6000036f9800,mstrOriginValue\n
    // aCopyMStr输出:0x6000036f96e0,mstrOriginValue\n
    // strongMStr输出:0x6000036f9800,mstrOriginValue\n
    // weakMStr输出:0x6000036f9800,mstrOriginValue\n
    // 引用计数2

strongMStr和weakMStr指针指向的内存地址都和mstrOrigin相同,但mstrOrigin内存引用计数为2，不为3，因为weakMStr虽然指向了数据内存地址（之后用C简称，见示意图1），但不会增加C计数。copy修饰的的aCopyMStr，赋值后则是自己单独开辟了一块内存，内存上保存“mstrOrigin”字符串，并指向。

拷贝示意图如下:

image.png

可见当我修改mstrOrigin的值的时候，必然不会影响aCopyMStr,只会影响strongMStr和weakMStr。我们来验证下

NSLog(@"------------------修改原值后------------------------");

    [mstrOrigin appendString:@"1"];
    NSLog(@"mstrOrigin输出:%p,%@\\n", mstrOrigin,mstrOrigin);
    NSLog(@"aCopyMStr输出:%p,%@\\n",_aCopyMStr,_aCopyMStr);
    NSLog(@"strongMStr输出:%p,%@\\n",_strongMStr,_strongMStr);
    NSLog(@"weakMStr输出:%p,%@\\n",_weakMStr,_weakMStr);

    // ------------------修改原值后------------------------
    // 2020-02-28 11:43:56.322278+0800 demo1[10175:1073105] mstrOrigin输出:0x600000111c50,mstrOriginValue1\n
    // 2020-02-28 11:43:56.322396+0800 demo1[10175:1073105] aCopyMStr输出:0x600000111920,mstrOriginValue\n
    // 2020-02-28 11:43:56.322524+0800 demo1[10175:1073105] strongMStr输出:0x600000111c50,mstrOriginValue1\n
    // 2020-02-28 11:43:56.322640+0800 demo1[10175:1073105] weakMStr输出:0x600000111c50,mstrOriginValue1\n

copy会重新开辟新的内存来保存一份相同的数据。被赋值对象和原值修改互不影响。strong和weak赋值都指向原来数据地址，区别是前者会对数据地址进行引用计数+1，后者不会.

引用计数是否+1有什么实质区别呢？

如果知道“值地址的引用计数为0时，地址上保存的值就会被释放”。那么区别就不难理解，weak修饰的指针A指向的值地址C，那么地址上当其他指向他的指针被释放的时候，这个值地址引用计数也就变为0了，这个A的值也就为nil了。换句话说当值地址C上没有其他强引用指针修饰的时候C就会被立即释放，A的值就变为nil了。

这里我们来初始化mstrOrigin和并将strongMStr设置为nil让C的引用计数为0，然后输出weakMStr，看是否为nil.
注：初始化和设为nil都可以将指针所指向的数据地址引用计数减少1

NSLog(@"-------初始化mstrOrigin和并将strongMStr设置为nil-------------");
    mstrOrigin = [[NSMutableString alloc]initWithString:@"mstrOriginChange2"];
    self.strongMStr = nil;
    NSLog(@"mstrOrigin输出:%p,%@\\n", mstrOrigin,mstrOrigin);
    NSLog(@"strongMStr输出:%p,%@\\n",_strongMStr,_strongMStr);
    NSLog(@"mstrOrigin输出:%p,%@\\n",mstrOrigin,mstrOrigin);
    NSLog(@"weakMStr输出:%p,%@\\n",_weakMStr,_weakMStr);
    // -------初始化mstrOrigin和并将strongMStr设置为nil-------------
    // mstrOrigin输出:0x6000027794a0,mstrOriginChange2\n
    // strongMStr输出:0x0,(null)\n
    // mstrOrigin输出:0x6000027794a0,mstrOriginChange2\n
    // weakMStr输出:0x0,(null)\n

可见之前引用计数2是mstrOrigin和strongMStr添加的。

结论：copy会重新开辟新的内存来保存一份相同的数据。被赋值对象和原值修改互不影响。strong和weak虽然都指向原来数据地址，原值修改的时候storng和weak会随之变化。区别是前者会对数据地址进行引用计数+1防止原地址值被释放，但后者不会，当其他值都不在指向值地址时，值地址被释放，weak的值也就是为nil了。我们称会对数据地址增加引用计数的为强引用，不改变引用计数的为弱引用

1.2 assign和weak的区别

对assign和weak修饰的值进行赋值，并输出指针结构地址和值

self.assignMStr= mstrOrigin;
self.weakMStr= mstrOrigin;
mstrOrigin = [[NSMutableStringalloc]initWithString:@"mstrOriginChange3"];
NSLog(@"weakMStr输出:%p,%@\\n",_weakMStr,_weakMStr);
NSLog(@"assignMStr输出:%p,%@\\n",self.assignMStr,self.assignMStr);

可以发现在输出assignMStr时会偶尔出现奔溃的情况。原因是发送了野指针的情况。assign同weak，指向C并且计数不+1，但当C地址引用计数为0时，assign不会对C地址进行B数据的抹除操作，只是进行值释放。这就导致野指针存在，即当这块地址还没写上其他值前，能输出正常值，但一旦重新写上数据，该指针随时可能没有值，造成奔溃。

1.3那retain是什么

ARC之前属性构造器的关键字是retain,copy,assign，strong和weak是ARC带出来的关键字。
retain现在同strong，就是指针指向值地址，同时进行引用计数加1。
上面代码有点多，所做的操作是mArrOrigin（value1,value2）赋值给copy,strong,weak修饰的aCopyMArr,strongMArr,weakMArr。通过给原数组增加元素，修改原数组元素值，然后输出mArrOrigin的引用计数，和数组地址，查看变化。
发现其中数组本身指向的内存地址除了aCopyMArr重新开辟了一块地址，strongMArr,weakMArr和mArrOrigin指针指向的地址是一样的。也就是说

容器可变变量中容器本身和非容器可变变量是一样的，copy深拷贝，strongMArr,weakMArr和assign都是浅拷贝

另外我们发现被拷贝对象mArrOrigin中的数据引用计数居然不是1而是3。也就是说容器内的数据拷贝都是进行了浅拷贝。同时当我们修改数组中的一个数据时strongMArr,weakMArr，aCopyMArr中的数据都改变了，说明：

容器可变变量中的数据在拷贝的时候都是浅拷贝

容器可变变量的拷贝结构如下图：

image.png

2.2非容器不变变量

典型例子是NSString

我们还是以代码引出结果
此处我们将strOrigin拷贝给aCopyStr，strongStr，weakStr，然后输出他们的值地址，发现他们四个的值地址一样，且strOrigin值的引用计数为3。修改strOrigin和发现strOrigin值地址改变，其他三个值地址不变，将aCopyStr，strongStr设为nil后，发现weakStr随之nil。

综合上面现象NSString和NSMutableString（非容器可变变量）基本相同，除了copy，NSString为浅拷贝，NSMutableString是深拷贝。那么为什么NSString的copy是浅拷贝呢，也就是说为什么aCopyStr不自己开辟一个独立的内存出来呢。答案很简单，因为不可变量的值不会改变，既然都不会改变，所以没必要重新开辟一个内存出来让aCopyStr指向他，直接指向原来值位置就可以了。示意图如下

image.png

所以非容器不可变量除了copy其他特性同非容器可变变量，copy是浅拷贝

2.3不可变容器变量

典型对象NSArray。该对象实验自行实验。但结论在这里给出，其实不实验也可以大概知道概率
在不可变容器变量中，容器本身都是浅拷贝包括copy，同NSString，容器里面的数据都是浅拷贝，同NSMutableArray。

3.总结
copy，strong，weak，assign的区别。

可变变量中，copy是重新开辟一个内存，strong，weak，assgin后三者不开辟内存，只是指针指向原来保存值的内存的位置，storng指向后会对该内存引用计数+1，而weak，assgin不会。weak，assgin会在引用保存值的内存引用计数为0的时候值为空，并且weak会将内存值设为nil，assign不会，assign在内存没有被重写前依旧可以输出，但一旦被重写将出现奔溃

不可变变量中，因为值本身不可被改变，copy没必要开辟出一块内存存放和原来内存一模一样的值，所以内存管理系统默认都是浅拷贝。其他和可变变量一样，如weak修饰的变量同样会在内存引用计数为0时变为nil。

容器本身遵守上面准则，但容器内部的每个值都是浅拷贝。

**综上所述，当创建property构造器创建变量value1的时候，使用copy，strong，weak，assign根据具体使用情况来决定。value1 = value2，如果你希望value1和value2的修改不会互相影响的就用用copy，反之用strong,weak,assign。如果你还希望原来值C(C是什么见示意图1)为nil的时候，你的变量不为nil就用strong,反之用weak和assign。weak和assign保证了不强引用某一块内存，如delegate我们就用weak表示，就是为了防止循环引用的产生。
另外，我们上面讨论的是类变量，直接创建局部变量默认是Strong修饰

补充：delegate为什么要用weak或者assign而不用strong

a创建对象b,b中有C类对象c，所以a对b有一个引用,b对c有一个引用，a.b引用计数分别为1，1。当c.delegate = b的时候，实则是对b有了一个引用，如果此时c的delegate用strong修饰则会对b的值内存引用计数+1，b引用计数为2。当a的生命周期结束，随之释放对b的引用，b的引用计数变为1，导致b不能释放，b不能释放又导致b对c的引用不能释放，c引用计数还是为1，这样就造成了b和c一直留在了内存中。

而要解决这个问题就是使用weak或者assign修饰delegate，这样虽然会有c仍然会对b有一个引用，但是引用是弱引用，当a生命周期结束的时候，b的引用计数变为0，b释放后随之c的引用消失，c引用计数变为0，释放。

不可变常量的特殊性

在2.2的讨论中如果
1.字符串改成小于10长度的字符串
2.NSString*strOrigin = @"strOrigin0123456";
初始化NSString，你都会发现strOrigin值内存引用计数将发生异常，通常表现为引用计数特别大，具体可以看下iOS中NSString的特别之处这篇文章