iOS中copy,strong,retain,weak和assign的区别
本文逻辑图:
![](http://upload-images.jianshu.io/upload_images/1829796-01df8f735749a62c.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/700)
在知道他们区别之前,我们首先要知道NSObject对象的赋值操作做了哪些操作。
A=C其实是在内存中创建了一个A,然后又开辟了一个内存C,C里面存放的着值B。
![](http://upload-images.jianshu.io/upload_images/1829796-fefe525bde028e51.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/538)
如下:
NSMutableString*tempMStr = [[NSMutableString alloc]initWithString:@"strValue"];
NSLog(@"tempMStr值地址:%p,tempMStr值%@,tempMStr值引用计数%@\\n", tempMStr,tempMStr,[tempMStr valueForKey:@"retainCount"]);
//输出tempMStr值地址:0x7a05f650,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为例
@property(copy,nonatomic)NSMutableString*aCopyMStr;
@property(strong,nonatomic)NSMutableString*strongMStr;
@property(weak,nonatomic)NSMutableString*weakMStr;
@property(assign,nonatomic)NSMutableString*assignMStr;
NSMutableString*mstrOrigin = [[NSMutableStringalloc]initWithString:@"mstrOriginValue"];
self.aCopyMStr= mstrOrigin;
self.strongMStr= 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(@"引用计数%@",[mstrOriginvalueForKey:@"retainCount"]);
//输出结果
//2016-09-01 15:19:13.134 lbCopy[1205:87583] mstrOrigin输出:0x7892a5e0,mstrOriginValue
//2016-09-01 15:19:13.135 lbCopy[1205:87583] aCopyMStr输出:0x7893deb0,mstrOriginValue
//2016-09-01 15:19:13.135 lbCopy[1205:87583] strongMStr输出:0x7892a5e0,mstrOriginValue
//2016-09-01 15:19:13.135 lbCopy[1205:87583] weakMStr输出:0x7892a5e0,mstrOriginValue
//2016-09-01 15:19:13.135 lbCopy[1205:87583] 引用计数2
strongMStr和weakMStr指针指向的内存地址都和mstrOrigin相同,但mstrOrigin内存引用计数为2,不为3,因为weakMStr虽然指向了数据内存地址(之后用C简称,见示意图1),但不会增加C计数。copy修饰的的aCopyMStr,赋值后则是自己单独开辟了一块内存,内存上保存“mstrOrigin”字符串,并指向。
拷贝示意图如下
![](http://upload-images.jianshu.io/upload_images/1829796-23d123453eb7707e.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/645)
可见当我修改mstrOrigin的值的时候,必然不会影响aCopyMStr,只会影响strongMStr和weakMStr。我们来验证下
NSLog(@"------------------修改原值后------------------------");
[mstrOriginappendString:@"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);
//输出结果
//2016-09-01 15:33:02.839 lbCopy[1205:87583] mstrOrigin输出:0x7892a5e0,mstrOrigin1
//2016-09-01 15:33:02.839 lbCopy[1205:87583] aCopyMStr输出:0x7893deb0,mstrOrigin
//2016-09-01 15:33:02.839 lbCopy[1205:87583] strongMStr输出:0x7892a5e0,mstrOrigin1
//2016-09-01 15:33:02.839 lbCopy[1205:87583] weakMStr输出:0x7892a5e0,mstrOrigin1
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
mstrOrigin = [[NSMutableStringalloc]initWithString:@"mstrOriginChange2"];
self.strongMStr=nil;
NSLog(@"mstrOrigin输出:%p,%@\\n", mstrOrigin,mstrOrigin);
NSLog(@"strongMStr输出:%p,%@\\n",_strongMStr,_strongMStr);
NSLog(@"weakMStr输出:%p,%@\\n",_weakMStr,_weakMStr);
输出结果
//2016-09-01 15:41:33.793 lbCopy[1247:100742] mstrOrigin输出:0x7874d140,mstrOriginChange2
//2016-09-01 15:41:33.793 lbCopy[1247:100742] strongMStr输出:0x0,(null)
//2016-09-01 15:41:33.794 lbCopy[1247:100742] weakMStr输出:0x0,(null)
可见之前引用计数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。
2.非NSMutableString的情况
<br />
上面我们讨论了典型的例子NSMutableString,即非容器可变变量。也就是说还存在其他三种类型需要讨论…
1.非容器不可变变量NSSting
2.容器可变变量NSMutableArray
3.容器不可变变量NSArray
更重要的是不同类型会有不同结果…,好吧,不要奔溃,上面一大段我们讨论了1/4,接下来我们要讨论其他的3/4情况。但好消息是,其他几种情况基本与上面非容器可变变量情况基本类似。
2.1容器可变变量
容器可变变量的典型例子就是NSMutableArray
下面代码可以忽略,只做参考用
@property(copy,nonatomic)NSMutableArray*aCopyMArr;
@property(strong,nonatomic)NSMutableArray*strongMArr;
@property(weak,nonatomic)NSMutableArray*weakMArr;
NSMutableArray*mArrOrigin = [[NSMutableArrayalloc]init];
NSMutableString*mstr1 = [[NSMutableStringalloc]initWithString:@"value1"];
NSMutableString*mstr2 = [[NSMutableStringalloc]initWithString:@"value2"];
NSMutableString*mstr3 = [[NSMutableStringalloc]initWithString:@"value3"];
[mArrOriginaddObject:mstr1];
[mArrOriginaddObject:mstr2];
//将mArrOrigin拷贝给aCopyMArr,strongMArr,weakMArr
self.aCopyMArr= mArrOrigin;
self.strongMArr= mArrOrigin;
self.weakMArr= mArrOrigin;
NSLog(@"mArrOrigin输出:%p,%@\\n", mArrOrigin,mArrOrigin);
NSLog(@"aCopyMArr输出:%p,%@\\n",_aCopyMArr,_aCopyMArr);
NSLog(@"strongMArr输出:%p,%@\\n",_strongMArr,_strongMArr);
NSLog(@"weakMArr输出:%p,%@\\n",_weakMArr,_weakMArr);
NSLog(@"weakMArr输出:%p,%@\\n",_weakMArr[0],_weakMArr[0]);
NSLog(@"mArrOrigin中的数据引用计数%@", [mArrOriginvalueForKey:@"retainCount"]);
NSLog(@"%p %p %p %p",&mArrOrigin,mArrOrigin,mArrOrigin[0],mArrOrigin[1]);
//以下是输出
2016-09-02 20:42:30.777 lbCopy[4207:475091] mArrOrigin输出:0x78f81680,(
value1,
value2
)
2016-09-02 20:42:30.777 lbCopy[4207:475091] aCopyMArr输出:0x7a041340,(
value1,
value2
)
2016-09-02 20:42:30.777 lbCopy[4207:475091] strongMArr输出:0x78f81680,(
value1,
value2
)
2016-09-02 20:42:30.777 lbCopy[4207:475091] weakMArr输出:0x78f81680,(
value1,
value2
)
2016-09-02 20:42:30.777 lbCopy[4207:475091] weakMArr输出:0x78f816a0,value1
2016-09-02 20:42:30.778 lbCopy[4207:475091] mArrOrigin中的数据引用计数(
3,
3
)
2016-09-02 20:42:30.778 lbCopy[4207:475091] 0xbffb4098 0x78f81680 0x78f816a0 0x78f81710
//以上是输出
//给原数组添加一个元素
[mArrOriginaddObject:mstr3];
NSLog(@"mArrOrigin输出:%p,%@\\n", mArrOrigin,mArrOrigin);
NSLog(@"aCopyMArr输出:%p,%@\\n",_aCopyMArr,_aCopyMArr);
NSLog(@"strongMArr输出:%p,%@\\n",_strongMArr,_strongMArr);
NSLog(@"weakMArr输出:%p,%@\\n",_weakMArr,_weakMArr);
NSLog(@"mArrOrigin中的数据引用计数%@", [mArrOriginvalueForKey:@"retainCount"]);
//修改原数组中的元素,看是否有随之变化
[mstr1appendFormat:@"aaa"];
NSLog(@"mArrOrigin输出:%p,%@\\n", mArrOrigin,mArrOrigin);
NSLog(@"aCopyMArr输出:%p,%@\\n",_aCopyMArr,_aCopyMArr);
NSLog(@"strongMArr输出:%p,%@\\n",_strongMArr,_strongMArr);
NSLog(@"weakMArr输出:%p,%@\\n",_weakMArr,_weakMArr);
//以下是输出
2016-09-02 20:42:30.778 lbCopy[4207:475091] mArrOrigin输出:0x78f81680,(
value1,
value2,
value3
)
2016-09-02 20:42:30.778 lbCopy[4207:475091] aCopyMArr输出:0x7a041340,(
value1,
value2
)
2016-09-02 20:42:30.778 lbCopy[4207:475091] strongMArr输出:0x78f81680,(
value1,
value2,
value3
)
2016-09-02 20:42:30.778 lbCopy[4207:475091] weakMArr输出:0x78f81680,(
value1,
value2,
value3
)
2016-09-02 20:42:30.779 lbCopy[4207:475091] mArrOrigin中的数据引用计数(
3,
3,
2
)
2016-09-02 20:42:30.779 lbCopy[4207:475091] mArrOrigin输出:0x78f81680,(
value1aaa,
value2,
value3
)
2016-09-02 20:42:30.779 lbCopy[4207:475091] aCopyMArr输出:0x7a041340,(
value1aaa,
value2
)
2016-09-02 20:42:30.779 lbCopy[4207:475091] strongMArr输出:0x78f81680,(
value1aaa,
value2,
value3
)
2016-09-02 20:42:30.779 lbCopy[4207:475091] weakMArr输/出:0x78f81680,(
value1aaa,
value2,
value3
)
//以上是输出
上面代码有点多,所做的操作是mArrOrigin(value1,value2)赋值给copy,strong,weak修饰的aCopyMArr,strongMArr,weakMArr。通过给原数组增加元素,修改原数组元素值,然后输出mArrOrigin的引用计数,和数组地址,查看变化。
发现其中数组本身指向的内存地址除了aCopyMArr重新开辟了一块地址,strongMArr,weakMArr和mArrOrigin指针指向的地址是一样的。也就是说
容器可变变量中容器本身和非容器可变变量是一样的,copy深拷贝,strongMArr,weakMArr和assign都是浅拷贝
另外我们发现被拷贝对象mArrOrigin中的数据引用计数居然不是1而是3。也就是说容器内的数据拷贝都是进行了浅拷贝。同时当我们修改数组中的一个数据时strongMArr,weakMArr,aCopyMArr中的数据都改变了,说明
容器可变变量中的数据在拷贝的时候都是浅拷贝
容器可变变量的拷贝结构如下图
![](http://upload-images.jianshu.io/upload_images/1829796-5fec2788d9c9c6b7.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/692)
2.2非容器不变变量
典型例子是NSString
我们还是以代码引出结果
@property(copy,nonatomic)NSString*aCopyStr;
@property(strong,nonatomic)NSString*strongStr;
@property(weak,nonatomic)NSString*weakStr;
@property(assign,nonatomic)NSString*assignStr;
NSLog(@"\\n\\n\\n\\n------------------不可变量实验------------------------");
NSString*strOrigin = [[NSStringalloc]initWithUTF8String:"strOrigin0123456"];
self.aCopyStr= strOrigin;
self.strongStr= strOrigin;
self.weakStr= strOrigin;
NSLog(@"strOrigin输出:%p,%@\\n", strOrigin,strOrigin);
NSLog(@"aCopyStr输出:%p,%@\\n",_aCopyStr,_aCopyStr);
NSLog(@"strongStr输出:%p,%@\\n",_strongStr,_strongStr);
NSLog(@"weakStr输出:%p,%@\\n",_weakStr,_weakStr);
NSLog(@"------------------修改原值后------------------------");
strOrigin =@"aaa";
NSLog(@"strOrigin输出:%p,%@\\n", strOrigin,strOrigin);
NSLog(@"aCopyStr输出:%p,%@\\n",_aCopyStr,_aCopyStr);
NSLog(@"strongStr输出:%p,%@\\n",_strongStr,_strongStr);
NSLog(@"weakStr输出:%p,%@\\n",_weakStr,_weakStr);
NSLog(@"------------------结论------------------------");
NSLog(@"strOrigin值值为改变,但strOrigin和aCopyStr指针地址和指向都已经改变,说明不可变类型值不可被修改,重新初始化");
self.aCopyStr=nil;
self.strongStr=nil;
NSLog(@"strOrigin输出:%p,%@\\n", strOrigin,strOrigin);
NSLog(@"aCopyStr输出:%p,%@\\n",_aCopyStr,_aCopyStr);
NSLog(@"strongStr输出:%p,%@\\n",_strongStr,_strongStr);
NSLog(@"weakStr输出:%p,%@\\n",_weakStr,_weakStr);
NSLog(@"------------------结论------------------------");
NSLog(@"当只有weakStr拥有C时,值依旧会被释放,同非容器可变变量");
//以下是输出
------------------不可变量实验------------------------
2016-09-02 21:08:44.053 lbCopy[4297:488549] strOrigin输出:0x7a2550d0,strOrigin0123456
2016-09-02 21:08:44.053 lbCopy[4297:488549] aCopyStr输出:0x7a2550d0,strOrigin0123456
2016-09-02 21:08:44.054 lbCopy[4297:488549] strongStr输出:0x7a2550d0,strOrigin0123456
2016-09-02 21:08:44.054 lbCopy[4297:488549] weakStr输出:0x7a2550d0,strOrigin0123456
2016-09-02 21:08:44.054 lbCopy[4297:488549] strOrigin值内存引用计数3
2016-09-02 21:08:44.054 lbCopy[4297:488549] ------------------修改原值后------------------------
2016-09-02 21:08:44.054 lbCopy[4297:488549] strOrigin输出:0x8c1f8,aaa
2016-09-02 21:08:44.054 lbCopy[4297:488549] aCopyStr输出:0x7a2550d0,strOrigin0123456
2016-09-02 21:08:44.054 lbCopy[4297:488549] strongStr输出:0x7a2550d0,strOrigin0123456
2016-09-02 21:08:44.055 lbCopy[4297:488549] weakStr输出:0x7a2550d0,strOrigin0123456
2016-09-02 21:08:44.055 lbCopy[4297:488549] ------------------结论------------------------
2016-09-02 21:08:44.055 lbCopy[4297:488549] strOrigin值值为改变,但strOrigin和aCopyStr指针地址和指向都已经改变,说明不可变类型值不可被修改,重新初始化
2016-09-02 21:08:44.059 lbCopy[4297:488549] strOrigin输出:0x8c1f8,aaa
2016-09-02 21:08:44.059 lbCopy[4297:488549] aCopyStr输出:0x0,(null)
2016-09-02 21:08:44.060 lbCopy[4297:488549] strongStr输出:0x0,(null)
2016-09-02 21:08:44.060 lbCopy[4297:488549] weakStr输出:0x0,(null)
2016-09-02 21:08:44.060 lbCopy[4297:488549] ------------------结论------------------------
2016-09-02 21:08:44.061 lbCopy[4297:488549]当只有weakStr拥有C时,值依旧会被释放,同非容器可变变量
//以上是输出
此处我们将strOrigin拷贝给aCopyStr,strongStr,weakStr,然后输出他们的值地址,发现他们四个的值地址一样,且strOrigin值的引用计数为3。修改strOrigin和发现strOrigin值地址改变,其他三个值地址不变,将aCopyStr,strongStr设为nil后,发现weakStr随之nil。
综合上面现象NSString和NSMutableString(非容器可变变量)基本相同,除了copy,NSString为浅拷贝,NSMutableString是深拷贝。那么为什么NSString的copy是浅拷贝呢,也就是说为什么aCopyStr不自己开辟一个独立的内存出来呢。答案很简单,因为不可变量的值不会改变,既然都不会改变,所以没必要重新开辟一个内存出来让aCopyStr指向他,直接指向原来值位置就可以了。示意图如下
![](http://upload-images.jianshu.io/upload_images/1829796-93b7a0f217ca3baa.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/644)
所以非容器不可变量除了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的特别之处这篇文章
项目地址https://github.com/ai966669/copy
交流qq:578172874
错误之处希望能帮忙提出来,O(∩_∩)O谢谢了
2017.10.6
儿子已经睡了,老婆在玩手机..
已经大半年没写代码了,技术没成熟却在年初开始和朋友开始摸索着自己弄了个小公司,摸索着做着产品,市场,运营这些工作,发现本来向往的工作还不如敲代码来的喜欢(这些话公司人肯定看不到)
趁着国庆长假好好修理了下简书上的一些文章,微微弥补下以前的误人子弟
我们公司运营的公众号【千手游戏】,现在由妹子运营着,有时间猿们可以捧个场
</div>
</div>
</div>