iOS进阶（一）block与property

iOS进阶（一）block与property

 

这篇读书笔记主要介绍了C语言内存分配、block疑难点、property的深刻理解，本身对这三块作了系统性的总结，但愿对你有所帮助。

C语言内存分配

Objective-C从名字来看就能够知道是一门超C语言，因此了解C语言的内存模型对于理解Objective-C的内存管理有很大的帮助。C语言内存模型图以下：

1-1 C内存分配.png

从图中能够看出内存被分红了5个区，每一个区存储的内容以下：

• 栈区(stack)：存放函数的参数值、局部变量的值等，由编译器自动分配释放，一般在函数执行结束后就释放了，其操做方式相似数据结构中的栈。栈内存分配运算内置于处理器的指令集，效率很高，可是分配的内存容量有限，好比iOS中栈区的大小是2M。

• 堆区(heap)：就是经过new、malloc、realloc分配的内存块，它们的释放编译器不去管，由咱们的应用程序去释放。若是应用程序没有释放掉，操做系统会自动回收。分配方式相似于链表。

• 静态区：全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另外一块区域。程序结束后，由系统释放。

• 常量区：常量存储在这里，不容许修改的。

• 代码区：存放函数体的二进制代码。

栈区在何时释放内存呢？咱们经过下面的一个例子来讲明下：

1 2 3 4 5

- (void)print {     int i = 10;     int j = 20;     NSLog(@"i+j = %d", (i+j)); }

在上面的代码中当程序执行到 } 的时候，变量i和j的做用域已经结束了，编译器就会自动释放掉i和j所占的内存，因此理解好做用域就理解了栈区的内存分配。

栈区和堆区的区别主要为如下几点：

• 对于栈来讲，内存管理由编译器自动分配释放；对于堆来讲，释放工做由程序员控制。

• 栈的空间大小比堆小许多。

• 栈是机器系统提供的数据结构，计算机会在底层对栈提供支持，因此分配效率比堆高。

• 栈中存储的变量出了做用域就无效了，而堆因为是由程序员进行控制释放的，变量的生命周期能够延长。

参考文章：

C程序的内存管理

C/C++内存管理详解

block

声明block属性的时候为何用copy呢？

在说明为何要用copy前，先思考下block是存储在栈区仍是堆区呢？其实block有3种类型：

• 全局块(_NSConcreteGlobalBlock)

• 栈块(_NSConcreteStackBlock)

• 堆块(_NSConcreteMallocBlock)

全局块存储在静态区（也叫全局区），至关于Objective-C中的单例；栈块存储在栈区，超出做用域则立刻被销毁。堆块存储在堆区中，是一个带引用计数的对象，须要自行管理其内存。

怎么判断一个block所在的存储位置呢？

• block不访问外界变量（包括栈中和堆中的变量）

block既不在栈中也不在堆中，此时就为全局块，ARC和MRC下都是如此。

• block访问外界变量

MRC环境下：访问外界变量的block默认存储在栈区。

ARC环境下：访问外界变量的block默认存放在堆中，其实是先放在栈区，在ARC状况下自动又拷贝到堆区，自动释放。

使用copy修饰符的做用就是将block从栈区拷贝到堆区，为何要这么作呢？咱们看下Apple官方文档给出的答案：

1-2 block copy.png

经过官方文档能够看出，复制到堆区的主要目的就是保存block的状态，延长其生命周期。由于block若是在栈上的话，其所属的变量做用域结束，该block就被释放掉，block中的__block变量也同时被释放掉。为了解决栈块在其变量做用域结束以后被释放掉的问题，咱们就须要把block复制到堆中。

不一样类型的block使用copy方法的效果也不同，以下所示：

block的类型 存储区域 复制效果

_NSConcreteStackBlock 栈 从栈复制到堆

_NSConcreteGlobalBlock 静态区(全局区) 什么也不作

_NSConcreteMallocBlock 堆 引用计数增长

加上__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了。能够经过一个图简单来描述一下：

1-3 __block.png

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是否存在的问题。

参考文章：

iOS Block详解

property

@synthesize和@dynamic分别有什么做用？

在说二者分别有什么做用前，咱们先看下@property的本质是什么：

1	@property = ivar + getter + setter;

从上面能够看出@property的本质就是ivar(实例变量)加存取方法(getter + setter)。在咱们属性定义完成后，编译器会自动生成该属性的getter和setter方法，这个过程就叫作自动合成。除了生成getter与setter方法，编译器还要自动向类中添加适当类型的实例变量，而且在属性名前面加下划线，以此作实例变量的名字。

@synthesize的做用就是若是你没有手动实现getter与setter方法，那么编译器就会自动为你加上这两个方法。

@dynamic的做用就是告诉编译器，getter与setter方法由用户本身实现，不自动生成。固然对于readonly的属性只须要提供getter便可。

若是都没有写@synthesize和@dynamic，那么默认的就是@synthesize var = _var;

为了加深对@synthesize和@dynamic的理解，咱们来看几个具体的例子，例子1代码以下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

@interface ViewController ()   @property (nonatomic, copy) NSString *name;   @end   @implementation ViewController   @dynamic name;   - (void)viewDidLoad {     [super viewDidLoad];       self.name = @"国士梅花";     NSLog(@"name is : %@", self.name); }   @end

咱们在进行编译的时候没有问题，可是运行的时候就会发生崩溃，崩溃的缘由以下：

1	'NSInvalidArgumentException', reason: '-[ViewController setName:]: unrecognized selector sent to instance 0x7fd28dd06000'

崩溃的缘由是不识别setName方法，这也验证了若是加入了@dynamic的话，编译系统就不会本身生成getter和setter方法了，须要咱们本身来实现。

咱们在来看下@synthesize合成实例变量的规则是什么？例子2代码以下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

@interface ViewController ()   @property (nonatomic, copy) NSString *name;   @end   @implementation ViewController   @synthesize name = _myName;   - (void)viewDidLoad {     [super viewDidLoad];       self.name = @"国士梅花";     NSLog(@"name is : %@", _myName); }   @end

从代码中能够看出，一、当咱们指定了成员变量的名称(指定为带下划线的myName)，就会生成指定的成员变量。若是代码中存在带下划线的name，就不会在生成了。二、若是是@synthesize name;还会生成一个名称为带下划线的name成员变量，也就是说若是没有指定成员变量的名称会自动生成一个属性同名的成员变量。三、若是是@synthesize name = _name; 就不会生成成员变量了。

在有了自动合成属性实例变量以后，@synthesize还有哪些使用场景呢？先搞清楚一个问题，何时不会使用自动合成？

• 同时重写了setter和getter时。

• 重写了只读属性的getter时。

• 使用了@dynamic时。

• 在@protocol中定义的全部属性。

• 在category中定义的全部属性。

• 重载的属性。

注意点：

• 在category中使用@property也是只会生成getter和setter方法的声明，若是真的须要给category增长属性的实现，须要借助于运行时的两个函数：objc_setAssociatedObject和objc_getAssociatedObject。

• 在protocol中使用property只会生成setter和getter方法声明，使用属性的目的是但愿遵照我协议的对象可以实现该属性。

weak、copy、strong、assgin分别用在什么地方？

什么状况下会使用weak关键字？

• 在ARC中，出现循环引用的时候，会使用weak关键字。

• 自身已经对它进行了一次强引用，没有必要再强调引用一次。

assgin适用于基本的数据类型，好比NSInteger、BOOL等。

NSString、NSArray、NSDictionary等常用copy关键字，是由于他们有对应的可变类型：NSMutableString、NSMutableArray、NSMutableDictionary；

除了上面的三种状况，剩下的就使用strong来进行修饰。

为何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，它们之间可能进行赋值操做，为确保对象中的字符串值不会无心间变更，应该在设置新属性时拷贝一份。