内存被分成了5个区,每个区存储的内容如下:
- 栈区(stack):存放函数的参数值、局部变量的值等,由编译器自动分配释放,通常在函数执行结束后就释放了,其操作方式类似数据结构中的栈。栈内存分配运算内置于处理器的指令集,效率很高,但是分配的内存容量有限,比如iOS中栈区的大小是2M。
- 堆区(heap):就是通过new、malloc、realloc分配的内存块,它们的释放编译器不去管,由我们的应用程序去释放。如果应用程序没有释放掉,操作系统会自动回收。分配方式类似于链表。
- 静态区:全局变量和静态变量的存储是放在一块的,初始化的全局变量和静态变量在一块区域,未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后,由系统释放。
- 常量区:常量存储在这里,不允许修改的。
- 代码区:存放函数体的二进制代码。
栈区和堆区的区别主要为以下几点:
- 对于栈来说,内存管理由编译器自动分配释放;对于堆来说,释放工作由程序员控制。
- 栈的空间大小比堆小许多。
- 栈是机器系统提供的数据结构,计算机会在底层对栈提供支持,所以分配效率比堆高。
- 栈中存储的变量出了作用域就无效了,而堆由于是由程序员进行控制释放的,变量的生命周期可以延长。
声明block属性的时候为什么用copy呢?
在说明为什么要用copy前,先思考下block是存储在栈区还是堆区呢?其实block有3种类型:
- 全局块(_NSConcreteGlobalBlock)
- 栈块(_NSConcreteStackBlock)
- 堆块(_NSConcreteMallocBlock)
全局块存储在静态区(也叫全局区),相当于Objective-C中的单例;栈块存储在栈区,超出作用域则马上被销毁。堆块存储在堆区中,是一个带引用计数的对象,需要自行管理其内存。
怎么判断一个block所在的存储位置呢?
- block不访问外界变量(包括栈中和堆中的变量)
block既不在栈中也不在堆中,此时就为全局块,ARC和MRC下都是如此。
- block访问外界变量
MRC环境下:访问外界变量的block默认存储在栈区。
ARC环境下:访问外界变量的block默认存放在堆中,实际上是先放在栈区,在ARC情况下自动又拷贝到堆区,自动释放。
使用copy修饰符的作用就是将block从栈区拷贝到堆区,为什么要这么做呢?
通过官方文档可以看出,复制到堆区的主要目的就是保存block的状态,延长其生命周期。因为block如果在栈上的话,其所属的变量作用域结束,该block就被释放掉,block中的__block变量也同时被释放掉。为了解决栈块在其变量作用域结束之后被释放掉的问题,我们就需要把block复制到
加上__block之后为什么就可以修改block外面的变量了?
我们先看下例子1:
1 2 3 4 5 6 7 8 9 10 11 | - (void)testMethod { int anInteger = 42;
void (^testBlock)(void) = ^{ NSLog(@"Integer is : %i", anInteger); };
anInteger = 50;
testBlock(); } |
运行后输出的结果如下:
1 | Integer is : 42 |
为什么不是50呢?这个问题稍后做解释。我们在看加入__block的情况,例子2如下:
1 2 3 4 5 6 7 8 9 10 11 | - (void)testMethod { __block int anInteger = 42;
void (^testBlock)(void) = ^{ NSLog(@"Integer is : %i", anInteger); };
anInteger = 50;
testBlock(); } |
运行后输出的结果如下:
1 | Integer is : 50 |
两次运行结果不一样,中间发生了什么呢?我们接下来来具体分析下。
在例子1中,block会把anInteger变量复制为自己私有的const变量,也就是说block会捕获栈上的变量(或指针),将其复制为自己私有的const变量。在例子1中,在进行anInteger = 50的操作的时候,block已经将其复制为自己的私有变量,所以这里的修改对block里面的anInteger不会造成任何影响。
在例子2中,anInteger是一个局部变量,存储在栈区的。给anInteger加入__block修饰符所起到的作用就是只要观察到该变量被block所持有,就将该变量在栈中的内存地址放到堆中,此时不管block外部还是内部anInterger的内存地址都是一样的,进而不管在block外部还是内部都可以修改anInterger变量的值,所以anInteger = 50之后,在block输出的值就是50了。
block中循环引用的问题?使用系统的block api是否也考虑循环引用的问题?weak与strong之间的区别?
在使用block的时候,我们要特别注意循环引用的问题,先来看一个循环引用的例子:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | @interface XYZBlockKeeper : NSObject
@property (nonatomic, copy) void (^block)(void);
@end
@implementation XYZBlockKeeper
- (void)configureBlock { self.block = ^{ [self doSomething]; }; }
@end |
在上面的代码中我们声明了一个block属性,所以self对block有一个强引用。而在block内部又对self进行了一次强引用,这样就形成了一个封闭的环,也就是我们经常说的强引用循环。引用关系如图:
1-4 strong retain cycle.png
在这种情况下,由于其相互引用,内存不能够进行释放,就造成了内存泄漏的问题。怎么解决循环引用的问题呢?我们经常通过声明一个weakSelf来解决循环引用的问题,更改后的代码如下:
1 2 3 4 5 6 | - (void)configureBlock { __weak typeof(self) weakSelf = self; self.block = ^{ [weakSelf doSomething]; }; } |
加入weakSelf之后,block对self就由强引用关系变成了弱引用关系,这样在属性所指的对象遭到摧毁时,属性值也会被清空,就打破了block捕获的作用域带来的循环引用。这跟设置self.block = nil是同样的道理。
在使用系统提供的block api需要考虑循环引用的问题吗?比如:
1 2 3 | [UIView animateWithDuration:0.5 animations:^{ [self doSomething]; }]; |
在这种情况下是不需要考虑循环引用的,因为这里只有block对self进行了一次强引用,属于单向的强引用,没有形成循环引用。
weak与strong有什么区别呢?先看一段代码:
1 2 3 4 5 6 7 8 | - (void)configureBlock { __weak typeof(self) weakSelf = self; self.block = ^{ [weakSelf doSomething]; // weakSelf != nil // preemption(抢占) weakSelf turned nil [weakSelf doAnotherThing]; }; } |
这段代码看起来很正常呀,但是在并发执行的时候,block的执行是可以抢占的,而且对weakSelf指针的调用时序不同可以导致不同的结果,比如在一个特定的时序下weakSelf可能会变成nil,这个时候在执行doAnotherThing就会造成程序的崩溃。为了避免出现这样的问题,采用__strong的方式来进行避免,更改后的代码如下:
1 2 3 4 5 6 7 8 9 | - (void)configureBlock { __weak typeof(self) weakSelf = self; self.block = ^{ __strong typeof(weakSelf) strongSelf = weakSelf; [strongSelf doSomething]; // strongSelf != nil // 在抢占的时候,strongSelf还是非nil的。 [strongSelf doAnotherThing]; }; } |
从代码中可以看出加入__strong所起的作用就是在抢占的时候strongSelf还是非nil的,避免出现nil的情况。
总结:
- 在block不是作为一个property的时候,可以在block里面直接使用self,比如UIView的animation动画block。
- 当block被声明为一个property的时候,需要在block里面使用weakSelf,来解决循环引用的问题。
- 当和并发执行相关的时候,当涉及异步的服务的时候,block可以在之后被执行,并且不会发生关于self是否存在的问题。
为什么NSString、NSDictionary、NSArray要使用copy修饰符呢?
要搞清楚这个问题,我们先来弄明白深拷贝与浅拷贝的区别,以非集合类与集合类两种情况来进行说明下,先看非集合类的情况,代码如下:
1 2 3 | NSString *name = @"国士梅花"; NSString *newName = [name copy]; NSLog(@"name memory address: %p newName memory address: %p", name, newName); |
运行之后,输出的信息如下:
1 | name memory address: 0x10159f758 newName memory address: 0x10159f758 |
可以看出复制过后,内存地址是一样的,没有发生变化,这就是浅复制,只是把指针地址复制了一份。我们改下代码改成[name mutableCopy],此时日志的输出信息如下:
1 | name memory address: 0x101b72758 newName memory address: 0x608000263240 |
我们看到内存地址发生了变化,并且newName的内存地址的偏移量比name的内存地址要大许多,由此可见经过mutableCopy操作之后,复制到堆区了,这就是深复制了,深复制就是内容也就进行了拷贝。
上面的都是不可变对象,在看下可变对象的情况,代码如下:
1 2 3 | NSMutableString *name = [[NSMutableString alloc] initWithString:@"国士梅花"]; NSMutableString *newName = [name copy]; NSLog(@"name memory address: %p newName memory address: %p", name, newName); |
运行之后日志输出信息如下:
1 | name memory address: 0x600000076e40 newName memory address: 0x6000000295e0 |
从上面可以看出copy之后,内存地址不一样,且都存储在堆区了,这是深复制,内容也就进行拷贝。在把代码改成[name mutableCopy],此时日志的输出信息如下:
1 | name memory address: 0x600000077380 newName memory address: 0x6000000776c0 |
可以看出可变对象copy与mutableCopy的效果是一样的,都是深拷贝。
总结:对于非集合类对象的copy操作如下:
- [immutableObject copy]; //浅复制
- [immutableObject mutableCopy]; //深复制
- [mutableObject copy]; //深复制
- [mutableObject mutableCopy]; //深复制
采用同样的方法可以验证集合类对象的copy操作如下:
- [immutableObject copy]; //浅复制
- [immutableObject mutableCopy]; //单层深复制
- [mutableObject copy]; //深复制
- [mutableObject mutableCopy]; //深复制
对于NSString、NSDictionary、NSArray等经常使用copy关键字,是因为它们有对应的可变类型:NSMutableString、NSMutableDictionary、NSMutableArray,它们之间可能进行赋值操作,为确保对象中的字符串值不会无意间变动,应该在设置新属性时拷贝一份。
weak 和strong的区别:
(weak和strong)不同的是当一个对象不再有strong类型的指针指向它的时候它会被释放 ,即使还有weak型指针指向它。
一旦最后一个strong型指针离去,这个对象将被释放,所有剩余的weak型指针都将被清除。
可能有个例子形容是妥当的。
想象我们的对象是一条狗,狗想要跑掉(被释放)。
strong型指针就像是栓住的狗。只要你用牵绳挂住狗,狗就不会跑掉。如果有5个人牵着一条狗(5个strong型指针指向1个对象),除非5个牵绳都脱落,否着狗是不会跑掉的。
weak型指针就像是一个小孩指着狗喊到:“看!一只狗在那”只要狗一直被栓着,小孩就能看到狗,(weak指针)会一直指向它。只要狗的牵绳脱落,狗就会跑掉,不管有多少小孩在看着它。
只要最后一个strong型指针不再指向对象,那么对象就会被释放,同时所有的weak型指针都将会被清除。