一、基本概念

就 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指向源对象，既可以实现拷贝的相互独立，互不干扰的宗旨，还不用生成新的内存，节省内存空间，一举两得。

copy/mutableCopy 的概念和目的（设计原则）与引用计数器完全无关，是两个相互独立的概念；

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

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

因为产生了新的对象，所以str3中的拷贝操作属于深拷贝。str3也就指向了新产生的对象的内存地址，于是乎引用计数器就是 1。而 str1和str2指针所指向的对象是相同的，且被str1和str2指向(引用)，所以最终引用计数器打印结果为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只是告诉编译器，帮我生成 setter和 getter方法，也就是声明并实现了四个方法：

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_ 这个方法即可。可以看到，使用 assgin 修饰的 age 相关色 setter 内部只是简单的对内存地址中的值进行赋值。而使用 copy 修饰的 name 的 setter 方法内部中调用了objc_setProperty()这个函数。

特别注意：strong 修饰的属性也是和 assign 一样，直接对 （self + 属性地址偏移）这个指针指向的地址进行了赋值。按理来讲，应该有 retain 操作的啊？

其实这里只是编译器生成了 C++ 相关的代码，还没有进入 LLVM 的编译前端阶段，所以编译器中和 ARC 相关的逻辑还没有被添加。更加科学的做法是在编译前端完成工作后生成的 .ll 文件中观察，或者直接在 runtime 的汇编代码中查看。这里，在 .ll 文件中其实调用的是 objc_setProperty_nonatomic_copy 方法：

setName:

但是最终都会调用到 reallySetProperty，所以无伤大雅：

objc_setProperty_nonatomic_copy

相关指令：clang -S -fobjc-arc -emit-llvm XKPerson.m -o XKPerson.ll。

所以，核心在 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 = 0，mutablecopy = 0，那么最终会调用objc_retain方法；

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

// 最后一个参数由 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); }

这里留个疑问：

如果用 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 修饰反而会崩溃，和使用 copy 修饰 NSMutableArray 时同理。

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

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

原因：copy 修饰得到的对象为不可变对象，调用对象的可变方法会崩溃；比如：Attempt to mutate immutable object with appendString.......

所以，切记哦?：

• 在属性中不要使用 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 无论是直接调用还是修饰属性，其本质是调用copyWithZone和mutableCopyWithZone方法；
3. 深浅复制的区别在于返回值是否为新创建的对象，和调用 copy 的哪个方法无关；
4. 使用 copy 修饰属性的关键目的是告诉使用者，这个不要直接修改属性所指向内存中的值；
5. 修饰可变类型的对象，比如可变数组，严禁使用 copy 修饰；
6. copy 的本质是调用 copy 协议中的两个方法，只是系统对字符串、数组、字典、NSNumber 和 Block 实现了该协议的两个方法，其中两个方法所实现的逻辑大同小异；
7. copy 修饰属性的本质是在 setter 中调用 objc 相关的 setProperty 来进行赋值，内部会调用 copyWithZone；
8. copy 修饰 Block 属性的本质仍然是调用 copy 方法，只是其内部实现是将存放在栈上的 block 转移到堆上，否则栈中的 Block 被销毁后会访问指向该 Block 的指针会产生坏内存访问问题；