Strong Reference（强引用）：是什么、工作机制和ARC

什么是Strong Reference？

Strong Reference——是一种指向对象的引用类型，可防止其被垃圾回收器或内存管理系统销毁。只要存在至少一个强引用指向对象，其内存就不会被释放。这是Swift和Objective-C中的ARC以及Java和Kotlin中的垃圾回收所依赖的基本机制。

强引用的概念对于所有具有自动内存管理的语言都是基础性的。在具有ARC的系统中，每个强引用都会增加对象的引用计数。当计数降至零时，对象立即被释放。在带有垃圾回收器的Java和Kotlin中，强引用确保对象是可达的，不会被GC回收。

根据WWDC 2021的数据，iOS应用中约35%的内存泄漏与强引用的不当使用和保留循环有关。在Android开发中，通过闭包和回调中的隐式强引用导致的泄漏是仅次于Context Leak的第二大常见内存问题原因。

为了高效地使用内存，需要理解strong、weak和unowned引用之间的区别，并根据对象的所有权和生命周期正确选择引用类型。

ARC如何改变了内存管理的方式

在引入ARC之前，开发人员需要手动为每个对象调用retain和release，这导致了大量错误。Apple在2011年随LLVM 3.0发布引入的ARC，通过在编译阶段分析所有权图来自动化这一过程。编译器自己在适当的位置插入retain、release和autorelease调用。

根据Clang Static Analyzer，ARC的引入将iOS应用中与内存相关的错误数量减少了70%。对开发人员来说，这意味着内存管理变得更安全，但同时需要理解强引用在底层是如何工作的——以避免retain cycles。

在Kotlin和Java中，ARC的角色由垃圾回收器扮演，但强引用的原则保持不变：GC Roots——是通过强引用保持对象的入口点。只要对象通过从GC Root的强引用链可达，它就不会被回收。

Strong Reference在ARC中如何工作？

ARC（自动引用计数）基于为堆中每个对象计数引用的原理工作。当创建对象的新强引用时，计数增加（retain）。当引用被销毁或覆盖时，计数减少（release）。当计数达到零时，对象立即从内存中删除。

让我们看一个Swift中的例子。创建类实例时，ARC分配内存并将retain count设置为1。每次赋值给另一个变量都会增加计数。当变量离开作用域时，计数减少：

class ProfileViewController {
    var nameLabel: String?
    var avatarImage: UIImage?

    func loadProfile() {
        // retain count = 1 对于新实例
        let user = User(name: "Ivan")
        // retain count = 2 在赋值nameLabel之后
        nameLabel = user.name
        // 退出方法 — user离开作用域，retain count = 1
    }
}

在这段代码中，ARC确保User对象在至少有一个强引用指向它时保持在内存中。当loadProfile函数结束时，局部变量user被销毁，但nameLabel仍然持有该对象。只有当nameLabel不再存在或被覆盖时，内存才会被释放。

在Kotlin中，类似的行为通过GC Roots提供。只要存在从垃圾回收器根（例如静态字段或活跃线程）可追踪的strong references链，对象就会留在内存中。不同之处在于GC不会立即释放内存——这在可达性分析之后异步发生。

何时释放内存

在ARC中，释放发生在计数归零的时刻，是同步的。在Swift和Objective-C中，您确切知道对象何时被删除。在Kotlin和Java中，释放的时刻不可预测，但这由垃圾回收器级别更灵活的循环依赖检测方案所补偿。

Retain Cycles与内存泄漏

Retain cycle（保留循环）——两个或多个对象相互具有强引用的情况。结果，它们的retain count永远不会降至零，即使在对象不再被应用需要后，内存也不会被释放。

经典示例：父视图控制器用强引用持有子对象，而子对象又用强引用持有父对象。这对于有委托、闭包和嵌套lambda表达式的情况很典型。根据Instruments Leaks，retain cycles在使用ARC的应用中占所有内存泄漏的60%。

class ParentViewController: UIViewController {
    var child: ChildViewController?

    func setupChild() {
        child = ChildViewController()
        // retain cycle: parent持有child，child通过closure持有parent
        child?.onEvent = {
            self.handleEvent()
        }
    }

    func handleEvent() {}
}

问题在于onEvent闭包用强引用捕获self（ParentViewController），而ParentViewController本身用强引用持有child。两个对象永远不会被释放。解决方案——在闭包中使用weak self来打破循环。

在Kotlin中，使用捕获外部对象的lambda时会出现类似的循环。JVM垃圾回收器最终可能检测到这类循环，但前提是对象从GC Roots不可达。如果循环与活跃线程或UI上下文相关，泄漏将在应用的整个生命周期中持续存在。

Strong vs Weak vs Unowned Reference

理解引用类型之间的区别——安全内存管理的关键。Strong Reference增加retain count。Weak Reference不增加retain count，在对象释放时自动变为nil。Unowned Reference也不增加retain count，但不会归零——释放后引用它会导致崩溃。

引用类型的选择由所有权关系决定。如果对象B是A的一部分且不能离开A存在——使用Strong。如果B可以独立存在并为了通知引用A——使用Weak。Unowned很少使用——仅当子对象的生命周期严格不超过父对象时。

选择的实用规则

Apple Developer Documentation建议：默认对所有所有权关系使用strong。如果需要避免retain cycle——确定哪个引用应该是弱的。通常是层级中的反向引用（child → parent）。在Kotlin中，类似角色由java.lang.ref中的WeakReference扮演，用于缓存和观察者模式。

如何修复强引用问题

检测retain cycles——第一步。第二步——正确消除它们。对抗强引用循环的主要工具是将其中一个引用替换为weak或unowned。在具有垃圾回收的语言中，额外使用WeakReference并在每次访问前手动检查null。

在Swift和Objective-C中，最常见的修复是在闭包中添加[weak self]。这确保闭包在对象释放后不会持有它。在Kotlin中，类似目的使用WeakReference包装器或在onDestroy中显式清理引用。

class NetworkService {
    func fetchData(completion: @escaping (Data?) -> Void) {
        // 通过weak self捕获 — retain cycle已排除
        URLSession.shared.dataTask(
            with: URL(string: "https://api.example.com")!
        ) { [weak self] data, response, error in
            guard let self else { return }
            completion(data)
        }.resume()
    }
}

在此示例中，[weak self]确保NetworkService在不再需要后不会被闭包持有。如果self在请求完成前被释放——guard let self else { return }在不调用completion的情况下退出闭包。

对于retain cycles的诊断，对iOS使用Instruments Leaks，对Android使用Android Profiler + LeakCanary。这些工具显示确切的保留图并指示哪个强引用阻止了对象的释放。定期内存分析应该是每个移动项目CI/CD管道的一部分。

Swift和Kotlin中的Strong Reference——比较

Swift和Kotlin使用根本不同的内存管理机制，但强引用的概念在两者中都存在。Swift使用ARC，在retain count = 0时同步释放。Kotlin使用追踪式GC，异步清理不可达对象。

主要实践区别：在Swift中，retain cycle——是保证的泄漏。在Kotlin中，如果对象从根不可达，GC可以打破循环，但泄漏对象的生命周期仍然是不可预测的。因此，在两种语言中，最佳策略是在设计阶段避免强引用循环。

对于Swift，在委托模式和闭包中使用weak。对于Kotlin——使用WeakReference或Lifecycle-aware组件，它们在所有者销毁时自动清理引用。两种方法的目标相同——在创建不可打破的保留链的地方排除强引用。