Objective-C Copy机制详解与实战技巧

1. Objective-C中的Copy机制深度解析

在iOS开发中，理解copy机制是掌握Objective-C内存管理的关键一环。作为一个从MRC时代走过来的开发者，我见过太多因为copy使用不当导致的诡异bug。本文将结合十多年的实战经验，带你彻底吃透Objective-C的copy机制。

1.1 为什么需要Copy？

在面向对象编程中，对象传递默认都是引用传递。这就带来一个潜在问题：当我们将一个可变对象赋值给属性时，外部代码可能在我们不知情的情况下修改这个对象的值。想象这样一个场景：

objective-c复制NSMutableString *nickname = [NSMutableString stringWithString:@"老张"];
User *user = [[User alloc] init];
user.nickname = nickname;

// 某处代码修改了nickname
[nickname appendString:@"(已离职)"];

如果不使用copy，user.nickname会意外变成"老张(已离职)"。这就是copy修饰符存在的核心价值——保护对象免受外部修改的影响。

1.2 Copy与内存管理

在ARC环境下，copy修饰符实际上是一种特殊的强引用。它与strong的关键区别在于：

• strong：直接持有原对象，引用计数+1
• copy：创建原对象的副本，并持有这个副本

通过以下测试代码可以清晰看到区别：

objective-c复制NSMutableString *original = [NSMutableString stringWithString:@"测试"];
NSLog(@"原始对象地址：%p 引用计数：%ld", original, CFGetRetainCount((__bridge CFTypeRef)original));

// 使用strong
NSString *strongRef = original;
NSLog(@"strong引用后 - 原始对象地址：%p 引用计数：%ld", original, CFGetRetainCount((__bridge CFTypeRef)original));

// 使用copy
NSString *copiedRef = [original copy];
NSLog(@"copy后 - 原始对象地址：%p 引用计数：%ld", original, CFGetRetainCount((__bridge CFTypeRef)original));
NSLog(@"副本对象地址：%p 引用计数：%ld", copiedRef, CFGetRetainCount((__bridge CFTypeRef)copiedRef));

输出结果会显示：

1. strong引用会增加原对象的引用计数
2. copy不会影响原对象的引用计数，而是创建一个新对象

注意：在MRC时代，copy修饰符会自动对副本对象执行retain操作，这是历史遗留问题。ARC下我们不需要再关心这个细节。

2. 深拷贝与浅拷贝的真相

2.1 概念辨析

很多开发者对深浅拷贝的理解存在误区。让我们先明确定义：

• 浅拷贝：只复制指针，新旧对象共享同一块内存
• 深拷贝：复制对象本身及其所有内容，新旧对象完全独立

但Objective-C中的实际情况要复杂得多。系统类的copy行为可以总结为以下规律：

2.2 集合类的特殊行为

集合类的copy行为最容易被误解。看这个例子：

objective-c复制NSMutableString *str1 = [NSMutableString stringWithString:@"A"];
NSMutableString *str2 = [NSMutableString stringWithString:@"B"];
NSArray *originalArray = @[str1, str2];

// 浅拷贝
NSArray *shallowCopy = [originalArray copy];

// 深拷贝
NSArray *deepCopy = [[NSArray alloc] initWithArray:originalArray copyItems:YES];

// 测试修改元素
[str1 appendString:@"修改"];

NSLog(@"原始数组：%@", originalArray);
NSLog(@"浅拷贝数组：%@", shallowCopy);
NSLog(@"深拷贝数组：%@", deepCopy);

输出结果会显示：

1. 浅拷贝数组会反映str1的修改
2. 深拷贝数组保持不变

但要注意：即使使用initWithArray:copyItems:，也只是对数组元素执行一层copy操作。如果元素本身是集合对象，需要实现真正的深拷贝应该使用NSKeyedArchiver：

objective-c复制NSArray *trueDeepCopy = [NSKeyedUnarchiver unarchiveObjectWithData:
                        [NSKeyedArchiver archivedDataWithRootObject:originalArray]];

3. 自定义类的Copy实现

3.1 NSCopying协议实践

让自定义类支持copy需要实现NSCopying协议。这里有个完整的示例：

objective-c复制@interface BankAccount : NSObject <NSCopying>
@property (nonatomic, copy) NSString *accountNumber;
@property (nonatomic, strong) NSDate *createDate;
@property (nonatomic, assign) double balance;
@property (nonatomic, strong) NSArray<Transaction *> *transactions;
@end

@implementation BankAccount

- (id)copyWithZone:(NSZone *)zone {
    BankAccount *copy = [[[self class] allocWithZone:zone] init];
    if (copy) {
        // 基础类型直接赋值
        copy->_balance = self->_balance;
        
        // 不可变对象使用copy
        copy->_accountNumber = [self->_accountNumber copy];
        
        // 可变对象需要深拷贝
        copy->_createDate = [self->_createDate copy]; // NSDate是不可变的
        
        // 集合对象的深拷贝
        copy->_transactions = [[NSArray alloc] initWithArray:self->_transactions copyItems:YES];
    }
    return copy;
}

@end

3.2 继承链中的Copy问题

在继承体系中实现copy需要特别注意：

objective-c复制@interface Animal : NSObject <NSCopying>
@property (nonatomic, copy) NSString *name;
@end

@implementation Animal
- (id)copyWithZone:(NSZone *)zone {
    Animal *copy = [[[self class] allocWithZone:zone] init];
    copy.name = [self.name copy];
    return copy;
}
@end

@interface Dog : Animal
@property (nonatomic, assign) int age;
@end

@implementation Dog
- (id)copyWithZone:(NSZone *)zone {
    Dog *copy = [super copyWithZone:zone]; // 先复制父类属性
    if (copy) {
        copy->_age = self->_age; // 再复制子类属性
    }
    return copy;
}
@end

常见陷阱：

1. 忘记调用super的copyWithZone:
2. 在子类中直接调用[self copy]会导致无限递归
3. 没有正确判断copy是否为nil

4. 实战中的Copy技巧与陷阱

4.1 Block必须使用copy

在MRC时代，block属性必须使用copy修饰符，这是因为：

objective-c复制@property (nonatomic, copy) void (^completionBlock)(void);

背后的原理是：

1. 栈上的block在离开作用域后会被销毁
2. copy操作会将block从栈复制到堆上
3. ARC下这个规则仍然适用，虽然编译器会自动处理

4.2 性能优化策略

不当使用copy可能导致性能问题：

1. 对于确定不会被修改的大对象，可以使用strong避免不必要的copy
2. 对于频繁创建的临时对象，考虑使用autoreleasepool管理内存
3. 使用懒加载延迟copy操作

objective-c复制@interface DataCache : NSObject
@property (nonatomic, copy) NSDictionary *config;
@end

@implementation DataCache {
    NSDictionary *_internalConfig;
}

- (NSDictionary *)config {
    if (!_internalConfig) {
        _internalConfig = [sourceDictionary copy];
    }
    return _internalConfig;
}

- (void)setConfig:(NSDictionary *)config {
    _internalConfig = [config copy];
}
@end

4.3 线程安全考量

虽然copy操作本身是原子的，但在多线程环境下仍需注意：

1. 对同一个对象的多次copy可能在不同线程中产生不同结果
2. 自定义的copyWithZone:实现应该保证线程安全
3. 避免在copy方法中执行耗时操作

objective-c复制- (id)copyWithZone:(NSZone *)zone {
    @synchronized(self) {
        MyClass *copy = [[[self class] allocWithZone:zone] init];
        copy.property1 = [self.property1 copy];
        // ...
        return copy;
    }
}

5. 经典问题排查

5.1 崩溃：unrecognized selector sent to instance

这个错误通常是因为：

1. 类没有实现NSCopying协议
2. 错误地认为NSObject默认实现了copyWithZone:

解决方案：

1. 确认类声明中包含了
2. 实现copyWithZone:方法

5.2 属性值被意外修改

即使使用了copy修饰符，仍可能遇到属性值被修改的情况，原因可能是：

1. 自定义类的copyWithZone:实现不正确
2. 嵌套的可变对象没有深拷贝

测试方法：

objective-c复制// 测试copy是否真的保护了属性
NSMutableString *mutableString = [NSMutableString stringWithString:@"测试"];
obj.stringProperty = mutableString;
[mutableString appendString:@"修改"];
NSAssert([obj.stringProperty isEqualToString:@"测试"], @"Copy保护失败");

5.3 内存泄漏问题

在MRC环境下，错误的copy实现可能导致内存泄漏：

objective-c复制// 错误的实现
- (id)copyWithZone:(NSZone *)zone {
    MyClass *copy = [[[self class] allocWithZone:zone] init];
    copy.property = [self.property retain]; // 应该使用copy而不是retain
    return copy;
}

在ARC环境下，这些问题会被编译器捕获，但仍需注意循环引用问题。

6. 最佳实践总结

经过多年实战，我总结了以下Objective-C copy使用准则：

1. 字符串属性一律使用copy：防止NSMutableString的意外修改
2. 可变集合使用strong，不可变集合使用copy：根据需求决定
3. block属性必须使用copy：保证生命周期正确
4. 自定义类实现NSCopying协议时：
   • 基础类型直接赋值
   • 不可变对象使用copy
   • 可变对象使用深拷贝
5. 性能敏感场景：
   • 大对象考虑延迟copy
   • 频繁创建的对象使用autoreleasepool
6. 多线程环境：
   • 保证copyWithZone:的线程安全
   • 避免在copy中执行IO操作

记住，copy不是银弹。在iOS开发中，理解每个选择背后的权衡比机械地应用规则更重要。当你犹豫是否该用copy时，问问自己：这个属性值是否应该完全独立于它的来源？如果是，就使用copy。