iOS:copy的本质

4,205

基本概念

就 iOS 开发而言,关于 copy 的几个概念:

  1. 拷贝:即复制,目的是产生副本,让原对象和副本相互独立,互不影响;
  2. 不可变拷贝:即 copy 方法,无论原对象是否可变,都产生不可变副本;
  3. 可变拷贝:即 mutableCopy 方法,无论原对象是否可变,都产生可变副本;
  4. 深拷贝:内容拷贝,产生新的对象;
  5. 浅拷贝:指针拷贝,不产生新的对象;

由上可知,copy 和深拷贝是两个概念,两者并不一定相等,先给结果:

  • 源对象不可变时,copy 方法就是浅拷贝;
  • 源对象可变时,copy 方法就是深拷贝;
  • mutableCopy 方法无论何种情况都是深拷贝;

代码分析

关闭 ARC 的情况下,先看两段代码:

情况一:NSString

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSString *str1 = [[NSString alloc] initWithFormat:@"123abcdefghijklmn"];
        NSString *str2 = [str1 copy];
        NSMutableString *str3 = [str1 mutableCopy];
        
        NSLog(@"%zd %zd %zd",str1.retainCount, str2.retainCount, str3.retainCount);
        NSLog(@"%p %p %p",str1, str2, str3);
    }
    return 0;
}

猜一猜打印的结果是什么?结果如下:

2019-12-26 17:23:23.020793+0800 XKCopyTest[1862:60872367] 2 2 1
2019-12-26 17:23:23.021176+0800 XKCopyTest[1862:60872367] 0x100610460 0x100610460 0x1006103b0
Program ended with exit code: 0

先不看引用计数器,先看看内存地址,从打印结果中可以看出:

  1. str1 是 NSString类型,属于不可变对象;
  2. str2 中的调用的 copy方法表示是不可变拷贝,需要得到一个不可变副本;
  3. str2 的地址和 str1 地址相等,没有产生新的对象;

由此可以进一步得出第一个结论:

  • str2 中的拷贝是浅拷贝;

因为str2地址不变, 指向的仍然是str1所指向的那个对象,没有产生新的对象,所以此时的拷贝是浅拷贝

  • 浅拷贝中的 copy 方法等价于retain

因为是浅拷贝,没有产生新的对象,指针 str2 仍然指向源对象,所以此时copy方法执行的逻辑等价于retain,也就是仅仅让源对象的引用计数器增加了1,所以最终 str1.retainCount的结果是 2 。因为 str2 指向源对象,所以自然而言的str2.retainCount的打印结果也是2。

这里需要解释下如此设计的原因,就像我们在使用 PC 文件时进行拷贝一样,拷贝的本质是要生成一个和源文件相互独立,互不干扰的副本,说具体点就是两个文件修改之后不影响另外一个文件。因为 str1 是不可变对象,copy方法生成的也是不可变对象,源对象本来就不可变,所以就不存在源对象被修改的情况了,所以直接把str2指向源对象,既可以实现拷贝的相互独立,互不干扰的宗旨,还不用生成新的内存,节省内存空间,一举两得。


再来看看 str3,从打印结果中我们可以得出:

  1. str3 中调用的mutableCopy表示可变拷贝,需要得到一个可变的副本;
  2. str3的地址和str1不相等,证明产生了一个新的对象;

因为产生了新的对象,所以str3中的拷贝操作属于深拷贝。str3也就指向了新产生的对象的内存地址,于是乎引用计数器就是 1。而 str1str2指针所指向的对象是相同的,且被str1str2指向(引用),所以最终引用计数器打印结果为2。


情况二:NSMutableString

str1改成可变类型,也就是NSMutableString,代码如下:

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSMutableString *str1 = [[NSMutableString alloc] initWithFormat:@"123abcdefghijklmn"];
        NSString *str2 = [str1 copy];
        NSMutableString *str3 = [str1 mutableCopy];
        
        NSLog(@"%zd %zd %zd",str1.retainCount, str2.retainCount, str3.retainCount);
        NSLog(@"%p %p %p",str1, str2, str3);
    }
    return 0;
}

打印结果又是怎么样的?结果如下:

2019-12-26 17:29:07.661591+0800 XKCopyTest[1937:60876834] 1 1 1
2019-12-26 17:29:07.661965+0800 XKCopyTest[1937:60876834] 0x10057c600 0x1005086d0 0x100508700
Program ended with exit code: 0

理解了情况一,再来看这个就比较简单了,从打印结果和代码中可以得出结论:

  • str2 中的拷贝属于深拷贝;

str2 中的 copy 仍然属于不可变拷贝,但是源对象是可变对象,所以必定会生成一个新对象,产生了新的对象就属于内容拷贝,自然就是深拷贝;

  • mutableCopy 必定是深拷贝;

mutableCopy 需要生成可变的副本,所以无论源对象是可变对象还是不可变对象,mutableCopy方法都会生成一个新的对象,所以必定是深拷贝。

对于 array、dictionary、data,也是同理,本文就不再赘述。


copy 修饰属性

上文中知道了,拷贝分深拷贝和浅拷贝,那么@property中的copy关键字是干嘛的呢?有没有 mutablecopy 关键字呢?

先说结论:

  • 属性中 copy 关键字的作用就是调用被赋值给属性的对象的copyWithZone方法,并将返回值赋值给属性;

再来看源码, 首先看一段我们常用的属性声明代码:

@interface XKPerson()
@property (copy, nonatomic) NSString *name;
@property (assign, nonatomic) NSInteger age;

@end

@implementation XKPerson

@end

使用编译指令生成 cpp 文件:

xcrun  -sdk  iphoneos  clang  -arch  arm64  -rewrite-objc XKPerson.m -o XKPerson.cpp

然后我们来找找property最后生成的代码是怎样的,cpp 文件中关于属性的实现代码如图所示:

// @interface XKPerson()
// @property (copy, nonatomic) NSString *name;
// @property (assign, nonatomic) NSInteger age;
/* @end */

// @implementation XKPerson

static NSString * _I_XKPerson_name(XKPerson * self, SEL _cmd) { return (*(NSString **)((char *)self + OBJC_IVAR_$_XKPerson$_name)); }
extern "C" __declspec(dllimport) void objc_setProperty (id, SEL, long, id, bool, bool);

static void _I_XKPerson_setName_(XKPerson * self, SEL _cmd, NSString *name) { objc_setProperty (self, _cmd, __OFFSETOFIVAR__(struct XKPerson, _name), (id)name, 0, 1); }

static NSInteger _I_XKPerson_age(XKPerson * self, SEL _cmd) { return (*(NSInteger *)((char *)self + OBJC_IVAR_$_XKPerson$_age)); }
static void _I_XKPerson_setAge_(XKPerson * self, SEL _cmd, NSInteger age) { (*(NSInteger *)((char *)self + OBJC_IVAR_$_XKPerson$_age)) = age; }
// @end

也就是说,@property只是告诉编译器,帮我生成 settergetter方法,也就是声明并实现了四个方法:

  1. static NSString * _I_XKPerson_name
  2. static void I_XKPerson_setName
  3. static NSInteger _I_XKPerson_age
  4. static void I_XKPerson_setAge

这里,因为我们在探究属性中的 copy,而且 copy 只在设置属性的时候起作用,所以我们只需要关注 _I_XKPerson_setName_ 这个方法即可,其核心是调用了objc_setProperty()这个函数,那么我们来到 objc4 的源码,下载 源码后看看objc_setProperty这个函数做了啥,代码如下:

#define MUTABLE_COPY 2

void objc_setProperty(id self, SEL _cmd, ptrdiff_t offset, id newValue, BOOL atomic, signed char shouldCopy) 
{
    bool copy = (shouldCopy && shouldCopy != MUTABLE_COPY);
    bool mutableCopy = (shouldCopy == MUTABLE_COPY);
    // copy 和 mutableCopy最多只有一个为真(1)
    reallySetProperty(self, _cmd, newValue, offset, atomic, copy, mutableCopy);
}

其余代码就不贴了,MUTABLE_COPY值为2,而setter中传的值为1,最终会进入到reallySetProperty这个方法:

static inline void reallySetProperty(id self, SEL _cmd, id newValue, ptrdiff_t offset, bool atomic, bool copy, bool mutableCopy)
{
    if (offset == 0) {
        // 修改 isa 指向
        object_setClass(self, newValue);
        return;
    }

    id oldValue;
    id *slot = (id*) ((char*)self + offset);

    // copy的逻辑
    if (copy) {
        // 属性修饰关键字只有 copy
        newValue = [newValue copyWithZone:nil];
    } else if (mutableCopy) {
        // 属性修饰关键字只有 copy , 这里是实现了 mutableCopying 协议时的处理逻辑
        newValue = [newValue mutableCopyWithZone:nil];
    } else {
        if (*slot == newValue) return;
        newValue = objc_retain(newValue);
    }

    if (!atomic) {
        oldValue = *slot;
        *slot = newValue;
    } else {
        spinlock_t& slotlock = PropertyLocks[slot];
        slotlock.lock();
        oldValue = *slot;
        *slot = newValue;        
        slotlock.unlock();
    }

    // 释放原对象
    objc_release(oldValue);
}

其实这段代码还是挺经典的,但是我们只看 copy 的部分:

// copy的逻辑
    if (copy) {
        // 属性修饰关键字只有 copy ,所以最终会进入到这里
        newValue = [newValue copyWithZone:nil];
    } else if (mutableCopy) {
        // 属性修饰关键字只有 copy , 这里是实现了 mutableCopying 协议时的处理逻辑
        newValue = [newValue mutableCopyWithZone:nil];
    } else {
        if (*slot == newValue) return;
        
        // NSString等不可变对象调用copy,其内部的代码逻辑会走到这里来
        // 此时 copy 不产生新的对象,属于浅拷贝,所以 copy 和 retain 的代码逻辑等价(但是可不能将 copy 关键字替换成 retain 哦😯~)
        newValue = objc_retain(newValue);
    }

从源码中就一目了然了:

  1. 如果是 copy 方法,则调用对象的 copyWithZone方法;
  2. 如果是mutablecopy,则调用对象的mutableCopyWithZone 方法;
  3. 如果 copy = 0mutablecopy = 0,那么最终会调用objc_retain方法;

其中,使用retain修饰属性时,就是第三种情况,代码中也可以得到验证,修改copyretain后编译的结果:

// 最后一个参数由 1 变成了 0
static void _I_XKPerson_setName_(XKPerson * self, SEL _cmd, NSString *name) { objc_setProperty (self, _cmd, __OFFSETOFIVAR__(struct XKPerson, _name), (id)name, 0, 0); }

另外,如果使用 strongassign修饰,最终 setter 不调用 objc_setProperty方法而是通过偏移量进行指针赋值或者直接赋值,具体就不再这里探讨了~~


这里留个疑问:

如果用 copy 修饰,那么属性最终转化成的 setter 中执行的 objc_setProperty 方法的传值中,最后一个参数永远为1。而objc_setProperty内部调用的也是reallySetProperty方法。为1时,调用reallySetProperty方法中的参数永远是bool copy = 1, bool mutablecopy = 0,也就是会走到copyWithZone这层逻辑。而使用 retain修饰属性,参数bool copy = 0, bool mutablecopy = 0,会走到obje_retain这层逻辑,归纳如下:

关键字 参数copy的值 参数mutablecopy的值 代码逻辑
retain 0 0 obje_retain()
copy 1 0 copyWithZone()

只有objc_setProperty最后一个参数为 2 时,才会走到 mutableCopy 的逻辑,所以reallySetProperty方法中的mutablecopyWithZone的代码何时会被调用呢???


使用 copy 修饰字符串意义

先说结论,使用 copy 修饰属性的意义在于:

  • 明确告诉使用者,设计者不希望且不能直接修改属性对象所指向的内存地址的值;

不希望体现在使用使用 NSString 类型来声明属性,这样如果使用 appendString:的方法,就报报编译错误。

但是,如果使用 strong 来修饰字符串属性,加上强制类型转换,仍然可以实现直接修改内存地址中的值:

// person对象中使用 strong 修饰 属性
@property (strong, nonatomic) NSString *name1;
XKPerson *p = [XKPerson new];
NSMutableString *name = [[NSMutableString alloc] initWithFormat:@"%@",@"Jack"];
// 此时如果是用 strong 修饰 name,虽然声明的是 NSString 对象,但实际类型是 NSMutableString 类型
p.name = name;
[(NSMutableString *)p.name appendFormat:@"1"];

以上代码就实现了直接修改属性所指向的内存地址中的值,此时修改成使用 copy 修饰,因为调用的copyWithZone,结果返回的必定是不可变类型,所以即使赋值时是NSMutableString类型,最终得到的仍然是NSString类型,这样就起到了预期的效果;

所以,NSString 类型使用 copy 修饰是最好不过的~~~

这里还涉及到一个场景,比如我们开发中,希望字符串属性跟随某个字符串对象的值同时改变,这个时候就要使用 strong + NSMutableString了:

@property (strong, nonatomic) NSMutableString *name;

// 使用
XKPerson *p = [XKPerson new];
    NSMutableString *name = [NSMutableString stringWithFormat:@"王"];
    p.name = name;
    NSLog(@"%@",p.name);
    [name appendString:@"小二"];
    NSLog(@"%@",p.name);

结果:

2019-12-27 17:53:51.730 XKStringTest[10172:63201310] 王
2019-12-27 17:53:51.731 XKStringTest[10172:63201310] 王小二

这个时候如果使用 copy 修饰,再使用[self.name appendString:@"xxx"] 反而会崩溃,和使用 copy 修饰 NSMutableArray 时同理。

再重申一遍:copy 是为了获得不可变副本,mutableCopy 是为了获取可变副本,而修饰属性的关键字只有 copy。

这个场景中使用其实应该使用 mutableCopy 修饰,创建的就是可变的独立字符串副本了,但是 没有 mutableCopy 关键字修饰属性。

所以,切记哦😯:

  • 在属性中不要使用 copy 修饰NSMutableArray、NSMutableDictionary等可变类型;

copy 协议

上一章节讲到了属性修饰中 copy 关键字的本质是调用copyWithZone方法。之所以能够使用 copy 修饰字符串、数组等,是因为这些系统对象实现了 copy 相关的协议。

所以,这里就涉及到一个问题:自定义copyWithZone方法。平常我们使用 copy 修饰的最多的就是字符串

因此,OC 中给我们提供了两个协议:

@protocol NSCopying
- (id)copyWithZone:(nullable NSZone *)zone;
@end

@protocol NSMutableCopying
- (id)mutableCopyWithZone:(nullable NSZone *)zone;
@end

具体实现如下:

- (id)copyWithZone:(NSZone *)zone {
    XKPerson *newP = [[XKPerson allocWithZone:zone] init];
    newP.name = self.name;
    newP.age = self.age;
    return newP;
}

- (id)mutableCopyWithZone:(NSZone *)zone {
    XKPerson *newP = [[XKPerson allocWithZone:zone] init];
    newP.name = self.name;
    newP.age = 10;
    return newP;
}

使用:

XKPerson *p = [XKPerson new];
    p.name = @"Jack";
    p.age = 18;
    XKPerson *p1 = [p copy];
    XKPerson *p2 = [p mutableCopy];
    NSLog(@"%p %p %p", p, p1, p2);
    
    p1.name = @"Lucy";
    NSLog(@"%@",p1.name);

结果:

2019-12-27 17:42:11.326 XKStringTest[9991:63192515] 0x7ae30b10 0x7ae31340 0x7ae313e0
2019-12-27 17:42:11.327 XKStringTest[9991:63192515] Lucy

copy 在数据模型 model 中时可能会较多使用 copy,此时实现copy协议即可,但在平时自定义对象使用 copy 并不多,这两个协议就不多说了~~

Block 为什么使用 copy 修饰

会在 block进阶中讲到,但是这里也把核心说一下,来看一段代码就能看到本质,非 ARC 模式下代码如下:

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // 看看 block 中 copy 方法的本质
        int age = 10;
        void(^block)(void) = ^(void){
            NSLog(@"%d",age);
        };
        
        NSLog(@"%p",block);
        NSLog(@"%@",[block class]);
        block = [block copy];
        NSLog(@"%p",block);
        NSLog(@"%@",[block class]);

    }
    return 0;
}

打印结果:

2020-01-03 09:02:36.888792+0800 XKBlockTest[84409:72373799] 0x7ffeefbff488
2020-01-03 09:02:36.889375+0800 XKBlockTest[84409:72373799] __NSStackBlock__
2020-01-03 09:02:36.889904+0800 XKBlockTest[84409:72373799] 0x1006444b0
2020-01-03 09:02:36.889961+0800 XKBlockTest[84409:72373799] __NSMallocBlock__

分析:

  1. 代码中只是为了测试,所以省去了 release 等操作;
  2. copy 的本质和字符串等的实现大同小异,都是返回一个不可变对象;
  3. 因为访问了 auto 变量的 Block 作为__NSStackBlock__存放在栈中,否则作为__NSGlobalBlock__存放在数据区(全局区),栈中的 Block 随时会被销毁,所以系统实现的 copy 操作在堆中创建了一个全新的 Block 并返回,这就是两次打印内存结果不一样的原因;
  4. Block 存放在堆中时被标记成__NSMallocBlock__类型,非 ARC 中需要手动 release
  5. Block 使用 copy 修饰时,同字符串等一样,会调用新值的 copy 方法,也就是 Block 的 copy 方法;
  6. Block 属性使用weak修饰不用多说,既不调用 copy 方法,也不增加引用计数器;

直接说总结吧:

因为 ARC 会在几种特定情况下主动调用 Block 的 copy 方法,比如被 strong 修饰时,GCD中的Block、系统的 UsingBlock 方法等,所以:

  • ARC 中的 Block 属性使用 copy 和 strong 修饰 Block 都可以
  1. 使用 copy 修饰时,相当于主动调用 copy 方法,StackBlock 会被拷贝到堆上而成为 MallocBlock;
  2. 使用 strong 修饰时,ARC 模式下,会自动调用 copy 方法,StackBlock 会被拷贝到堆上而成为 MallocBlock;
  • MRC 中的 Block 属性必须使用 copy 修饰
  1. 使用 copy 修饰时,相当于主动调用 copy 方法,StackBlock 会被拷贝到堆上而成为 MallocBlock;
  2. MRC 模式下,strong 修饰 Block 只会 retain,不会自动调用 Block 的 copy 方法;

总结

以上,总结下 copy 的几个重点,方便记忆:

  1. copy 的目的是创建一个互不干扰,相互独立的副本;
  2. copy 无论是直接调用还是修饰属性,其本质是调用copyWithZonemutableCopyWithZone方法;
  3. 深浅复制的区别在于返回值是否为新创建的对象,和调用 copy 的哪个方法无关;
  4. 使用 copy 修饰属性的关键目的是告诉使用者,这个不要直接修改属性所指向内存中的值;
  5. 修饰可变类型的对象,比如可变数组,严禁使用 copy 修饰;
  6. copy 的本质是调用 copy 协议中的两个方法,只是系统对字符串、数组、字典、NSNumber 和 Block 实现了该协议的两个方法,其中两个方法所实现的逻辑大同小异;
  7. copy 修饰属性的本质是自动调用新值的 copy 方法以获取一个不可变对象,属性无 mutableCopy 修饰,因为没有必要;
  8. copy 修饰 Block 属性的本质仍然是调用 copy 方法,只是其内部实现是将存放在栈上的 block 转移到堆上,否则栈中的 Block 被销毁后会访问指向该 Block 的指针会产生坏内存访问问题;

更多文章