基本概念

就 iOS 开发而言，关于 copy 的几个概念：

拷贝：即复制，目的是产生副本，让原对象和副本相互独立，互不影响；
不可变拷贝：即 copy 方法，无论原对象是否可变，都产生不可变副本；
可变拷贝：即 mutableCopy 方法，无论原对象是否可变，都产生可变副本；
深拷贝：内容拷贝，产生新的对象；
浅拷贝：指针拷贝，不产生新的对象；

由上可知，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

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

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

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

str2 中的拷贝是浅拷贝；

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

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

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

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

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

str3 中调用的mutableCopy表示可变拷贝，需要得到一个可变的副本；
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方法，也就是声明并实现了四个方法：

static NSString * _I_XKPerson_name
static void I_XKPerson_setName
static NSInteger _I_XKPerson_age
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);
    }

从源码中就一目了然了：

如果是 copy 方法，则调用对象的 copyWithZone方法；
如果是mutablecopy，则调用对象的mutableCopyWithZone 方法；
如果 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); }

另外，如果使用 strong 和 assign修饰，最终 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__

分析：

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

直接说总结吧：

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

ARC 中的 Block 属性使用 copy 和 strong 修饰 Block 都可以

使用 copy 修饰时，相当于主动调用 copy 方法，StackBlock 会被拷贝到堆上而成为 MallocBlock；
使用 strong 修饰时，ARC 模式下，会自动调用 copy 方法，StackBlock 会被拷贝到堆上而成为 MallocBlock；

MRC 中的 Block 属性必须使用 copy 修饰

使用 copy 修饰时，相当于主动调用 copy 方法，StackBlock 会被拷贝到堆上而成为 MallocBlock；
MRC 模式下，strong 修饰 Block 只会 retain，不会自动调用 Block 的 copy 方法；

总结

以上，总结下 copy 的几个重点，方便记忆：

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