探索weak、strong、copy、assign、__weak

更新：

• 2018.10.12 修改了copy与strong修饰NSString、NSArray这些类型的解释和用法

开发环境:

Mac系统版本：macOS Mojave 10.14（18A391）
Xcode：Version 10.0 (10A255)

结论:

就怕你想看结论又不想看长篇大论，就把结论写到上面，免得你滑屏幕累得慌

• strong 表示指向并拥有该对象。其修饰的对象引用计数会增加 1。该对象只要引用计数不为 0 则不会被销毁。当然强行将其设为 nil 可以销毁它。
• weak 表示指向但不拥有该对象。其修饰的对象引用计数不会增加。无需手动设置，该对象会自行在内存中销毁。
• assign 主要用于修饰基本数据类型，如 NSInteger 和 CGFloat ，这些数值主要存在于栈上。
• weak 一般用来修饰对象，assign 一般用来修饰基本数据类型。
• copy 与 strong 类似。不同之处是 strong 的复制是多个指针指向同一个地址，而 copy 的复制每次会在内存中拷贝一份对象，指针指向不同地址。
• __weak、__strong与weak、strong类似，区别是__weak、__strong修饰变量，而weak、strong修饰属性，而且__weak、__strong基本上都是与block相关；
• 如果对象类型有对应的可变类型，例如NSString、NSArray、NSDictionary等，需要结合场景合理使用，而对应的可变类型用strong，使用copy会导致崩溃；
• delegate使用weak修饰；
• 各种视图控件推荐使用weak，官方就是这样做的；

探索:

1. 为什么assign不能用来修饰对象类型？

我先引用故胤道长在《iOS面试之道》这本书中的回答：
assign 修饰的对象被释放后，指针的地址依然存在，造成野指针，在堆上容易造成崩溃。而栈上的内存系统会自动处理，不会造成野指针。
总之一句话，使用assign修饰对象容易造成崩溃。

代码验证环节：

/// 定义一个assign修饰的字符串变量
@property (nonatomic, readwrite, assign) NSString *string_assign;

/// 验证代码
- (void)influenceForNSStringWithAssign {
    /// 此时self.string_assign的值为 null
    NSLog(@"赋值前：string_assign = %@", self.string_assign);
    {
        NSMutableString *temp = [NSMutableString stringWithString:@"hello world"];
        self.string_assign = temp;
        /// 此处self.string_assign的值为 hello world
        NSLog(@"赋值后：string_assign = %@", self.string_assign);
        [temp appendString:@" changed"];
        /// 此时self.string_assign的值为 hello world changed
        NSLog(@"原始值修改后：string_assign = %@", self.string_assign);
    }
    /// 此时超出temp的作用域，temp被释放，self.string_assign的指针地址依然存在，成为野指针，此时使用self.string_assign就会造成崩溃
    NSLog(@"超出原始值的作用于后：string_assign = %@\n\n", self.string_assign);
}

/// 控制台输出
2018-10-10 17:58:29.141563+0800 MemoryManagerDemo[36403:5926424] 赋值前：string_assign = (null)
2018-10-10 17:58:29.141712+0800 MemoryManagerDemo[36403:5926424] 赋值后：string_assign = hello world
2018-10-10 17:58:29.141827+0800 MemoryManagerDemo[36403:5926424] 原始值修改后：string_assign = hello world changed
(lldb) /// 此处崩溃

2. 使用copy和strong修饰NSString、NSArray这类有对应可变类型的对象类型有什么区别？

在对对象赋值的时候，如果是使用copy修饰，那么会在内存中将原对象的值拷贝一份，原对象与该对象指向的是不同的内存区域，原对象在之后做任何修改都与该对象无关；

而如果是使用strong修饰，那么该对象与原对象虽然是不同的指针对象，但指向的都是同一片内存区域，如果原对象进行了修改，那么即使这个对象是不可变的，它的值也会发生变化；

如果确定在赋值之后，原值不会修改，那么使用strong是比较好的选择，毕竟，copy会消耗系统资源，能省一点是一点吧。但是，如果是要对外开放的，需要外部使用人员赋值的，建议还是使用copy，因为你不知道他们会不会改变，你也控制不了，所以为了安全起见，而且对外开放提供给别人使用的肯定不会特别多，那么有限的几个copy消耗点资源比起安全来，又有什么大不了的呢？

代码验证环节：

/// 先定义两个使用不同修饰符的属性
@property (nonatomic, readwrite, strong) NSString *string_strong;
@property (nonatomic, readwrite, copy) NSString *string_copy;

- (void)influenceForNSStringWithStrong {
    NSLog(@"开始测试strong对NSString的影响");
    NSLog(@"赋值前：string_strong = %@", self.string_strong); /* string_strong = (null) */
    {
        NSMutableString *temp = [NSMutableString stringWithString:@"hello world"];
        self.string_strong = temp;
        NSLog(@"赋值后：string_strong = %@", self.string_strong); /* string_strong = hello world */
        [temp appendString:@" changed"];
        NSLog(@"原始值修改后：string_strong = %@", self.string_strong); /* hello world changed */
    }
    NSLog(@"超出原始值的作用于后：string_strong = %@\n\n", self.string_strong); /* hello world changed */
}

- (void)influenceForNSStringWithCopy {
    NSLog(@"开始测试copy对NSString的影响");
    NSLog(@"赋值前：string_copy = %@", self.string_copy); /* string_copy = (null) */
    {
        NSMutableString *temp = [NSMutableString stringWithString:@"hello world"];
        self.string_copy = temp;
        NSLog(@"赋值后：string_copy = %@", self.string_copy); /* string_copy = hello world */
        [temp appendString:@" changed"];
        NSLog(@"原始值修改后：string_copy = %@", self.string_copy); /* string_copy = hello world */
    }
    NSLog(@"超出原始值的作用于后：string_copy = %@\n\n", self.string_copy); /* string_copy = hello world */
}

/// 控制台输出
2018-10-10 18:15:24.559236+0800 MemoryManagerDemo[36553:5936151] 开始测试strong对NSString的影响
2018-10-10 18:15:24.559368+0800 MemoryManagerDemo[36553:5936151] 赋值前：string_strong = (null)
2018-10-10 18:15:24.559460+0800 MemoryManagerDemo[36553:5936151] 赋值后：string_strong = hello world
2018-10-10 18:15:24.559551+0800 MemoryManagerDemo[36553:5936151] 原始值修改后：string_strong = hello world changed
2018-10-10 18:15:24.559650+0800 MemoryManagerDemo[36553:5936151] 超出原始值的作用于后：string_strong = hello world changed


2018-10-10 18:15:24.559742+0800 MemoryManagerDemo[36553:5936151] 开始测试copy对NSString的影响
2018-10-10 18:15:24.559860+0800 MemoryManagerDemo[36553:5936151] 赋值前：string_copy = (null)
2018-10-10 18:15:24.559957+0800 MemoryManagerDemo[36553:5936151] 赋值后：string_copy = hello world
2018-10-10 18:15:24.560050+0800 MemoryManagerDemo[36553:5936151] 原始值修改后：string_copy = hello world
2018-10-10 18:15:24.560151+0800 MemoryManagerDemo[36553:5936151] 超出原始值的作用于后：string_copy = hello world

3. 为什么说weak修饰的对象会自行在内存中销毁？

这就没啥说的了，直接代码验证：

@property (nonatomic, readwrite, weak) NSString *string_weak;

- (void)influenceForNSStringWithWeak {
    NSLog(@"开始测试weak对NSString的影响");
    NSLog(@"赋值前：string_weak = %@", self.string_weak); /* string_weak = (null) */
    {
        NSMutableString *temp = [NSMutableString stringWithString:@"hello world"];
        self.string_weak = temp;
        NSLog(@"赋值后：string_weak = %@", self.string_weak); /* string_weak = hello world */
        [temp appendString:@" changed"];
        NSLog(@"原始值修改后：string_weak = %@", self.string_weak); /* string_weak = hello world changed */
    }
    /* string_weak = (null) ，此处已经超出了temp的作用域了，而temp又没有其他的引用，就会被释放，string_weak自然就为null了*/
    NSLog(@"超出原始值的作用于后：string_weak = %@\n\n", self.string_weak); 
}

/// 控制台输出
2018-10-10 18:22:54.118462+0800 MemoryManagerDemo[36613:5941777] 开始测试weak对NSString的影响
2018-10-10 18:22:54.118845+0800 MemoryManagerDemo[36613:5941777] 赋值前：string_weak = (null)
2018-10-10 18:22:54.119251+0800 MemoryManagerDemo[36613:5941777] 赋值后：string_weak = hello world
2018-10-10 18:22:54.119474+0800 MemoryManagerDemo[36613:5941777] 原始值修改后：string_weak = hello world changed
2018-10-10 18:22:54.119673+0800 MemoryManagerDemo[36613:5941777] 超出原始值的作用于后：string_weak = (null)

4. 为什么不能用copy修饰NSMutableString这种可变对象？

@property (nonatomic, readwrite, strong) NSMutableString *mutableString_strong;
@property (nonatomic, readwrite, copy) NSMutableString *mutableString_copy;

- (void)influenceForNSMutableStringWithCopy {
    NSString *temp = @"hello world";
    self.mutableString_strong = [NSMutableString stringWithString:temp];
    self.mutableString_copy = [NSMutableString stringWithString:temp];
    [self.mutableString_strong appendString:@" changed"];
    [self.mutableString_copy appendString:@" changed"];
}

/// 控制台输出
2018-10-10 20:35:49.432473+0800 MemoryManagerDemo[36990:5966214] *** Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: 'Attempt to mutate immutable object with appendString:'
*** First throw call stack:
(
    0   CoreFoundation                      0x000000011124329b __exceptionPreprocess + 331
    1   libobjc.A.dylib                     0x00000001107df735 objc_exception_throw + 48
    2   CoreFoundation                      0x00000001112430f5 +[NSException raise:format:] + 197
    3   CoreFoundation                      0x0000000111189dc9 mutateError + 121
    4   MemoryManagerDemo                   0x000000010febf6f5 -[ViewController influenceForNSMutableStringWithCopy] + 309
    5   MemoryManagerDemo                   0x000000010febf3fb -[ViewController influenceForNSMutableString:] + 59
    6   UIKitCore                           0x0000000114ee47c3 -[UIApplication sendAction:to:from:forEvent:] + 83
    7   UIKitCore                           0x000000011501ce85 -[UIControl sendAction:to:forEvent:] + 67
    8   UIKitCore                           0x000000011501d1a2 -[UIControl _sendActionsForEvents:withEvent:] + 450
    9   UIKitCore                           0x000000011501c0e6 -[UIControl touchesEnded:withEvent:] + 583
    10  UIKitCore                           0x00000001156f7334 -[UIWindow _sendTouchesForEvent:] + 2729
    11  UIKitCore                           0x00000001156f8a30 -[UIWindow sendEvent:] + 4080
    12  UIKitCore                           0x0000000114efee10 -[UIApplication sendEvent:] + 352
    13  UIKitCore                           0x0000000114e370d0 __dispatchPreprocessedEventFromEventQueue + 3024
    14  UIKitCore                           0x0000000114e39cf2 __handleEventQueueInternal + 5948
    15  CoreFoundation                      0x00000001111a6b31 __CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__ + 17
    16  CoreFoundation                      0x00000001111a6464 __CFRunLoopDoSources0 + 436
    17  CoreFoundation                      0x00000001111a0a4f __CFRunLoopRun + 1263
    18  CoreFoundation                      0x00000001111a0221 CFRunLoopRunSpecific + 625
    19  GraphicsServices                    0x00000001198f41dd GSEventRunModal + 62
    20  UIKitCore                           0x0000000114ee3115 UIApplicationMain + 140
    21  MemoryManagerDemo                   0x000000010febfce0 main + 112
    22  libdyld.dylib                       0x0000000112ba9551 start + 1
    23  ???                                 0x0000000000000001 0x0 + 1
)
libc++abi.dylib: terminating with uncaught exception of type NSException
(lldb) 

上面的代码执行后，会导致崩溃，可以看到上面控制台输出的崩溃记录，奔溃的原因是Attempt to mutate immutable object with appendString:，这句话的意思是尝试用附件字符串来改变不可变对象：，我们创建的对象明明是可变的，为什么在改变的时候却因为该对象不可改变而崩溃呢？其实这就是copy的贡献了。接下来我们输出他们赋值之后的类型你就会明白了，看下图。

验证.png
看到了吗？经过赋值之后strong修饰的对象依然是NSMutableString，然而copy修饰的对象却变成了NSString，这是为什么呢？
其实，这是因为所有的这种可变类型都是继承对应的不可变类型，然而，却没有重写不可变类型的copy方法，当使用copy修饰的时候，调用不可变类型的copy方法，得到的其实是一个不可变的对象，此时，我们去修改它，自然就会报错了。

结尾:

最近在看唐巧大神和故胤道长一起写的《iOS面试之道》和《Objective-C高级编程 iOS与OS X多线程和内存管理》这两本书，突然心血来潮，以前没仔细研究过，这次就研究了一下，把不定期更新的博客更新一下，有用你就给个喜欢，没用就当看个热闹，想认识交流技术的就关注一下，关注我的我也会关注你哦。