iOS程序内存释放问题及解决方案

一切随缘3
2,217 阅读5分钟

1. 引言

  • 介绍内存管理的重要性：在iOS开发中，内存管理是一个关键部分。未能正确管理内存会导致内存泄漏，进而影响应用性能，甚至导致应用崩溃。

  • 说明内存泄漏可能带来的问题：内存泄漏会导致应用占用过多的内存，响应速度变慢，最终用户体验变差。长期的内存泄漏还会导致应用崩溃。

2. 内存泄漏的常见原因

  • Block块中的强引用

  • 多层Block块嵌套中的引用问题

  • 子视图的delegate未释放

  • 子视图的互相引用问题

  • 未正确释放子视图导致的整体视图无法释放

  • 自引用问题

3. 具体问题及解决方案

3.1. Block块中的强引用

问题解释

在Swift中，block（闭包）默认会对其捕获的对象（包括self）进行强引用。这意味着，闭包中的self会被闭包持有，导致self无法被释放，从而造成内存泄漏。

代码示例

以下代码展示了一个简单的内存泄漏问题：

class MyViewController: UIViewController {
    var myBlock: (() -> Void)?

    override func viewDidLoad() {
        super.viewDidLoad()
        
        myBlock = {
            self.doSomething() // 这里的self被闭包强引用，导致内存泄漏
        }
    }
    
    func doSomething() {
        print("Doing something")
    }
    
    deinit {
        print("MyViewController deinit")
    }
}

解决方案：使用 [weak self]

通过使用 [weak self]，可以将闭包对self的强引用改为弱引用，从而避免内存泄漏：

class MyViewController: UIViewController {
    var myBlock: (() -> Void)?

    override func viewDidLoad() {
        super.viewDidLoad()
        
        myBlock = { [weak self] in
            guard let self = self else { return }
            self.doSomething()
        }
    }
    
    func doSomething() {
        print("Doing something")
    }
    
    deinit {
        print("MyViewController deinit")
    }
}

3.2. 多层Block块嵌套中的引用问题

问题解释

当多层闭包嵌套时，可能会在每一层都使用 [weak self]，这不仅增加了代码的复杂性，还可能导致引用失效。正确的方法是在最外层使用 [weak self]，以确保内部的闭包也能使用到弱引用的self。

代码示例

以下代码展示了多层闭包嵌套中的内存泄漏问题：

class MyViewController: UIViewController {
    var myBlock: (() -> Void)?

    override func viewDidLoad() {
        super.viewDidLoad()
        
        myBlock = {
            self.someMethod {
                self.anotherMethod {
                    self.doSomething() // 这里的self被闭包强引用，导致内存泄漏
                }
            }
        }
    }
    
    func someMethod(completion: @escaping () -> Void) {
        completion()
    }
    
    func anotherMethod(completion: @escaping () -> Void) {
        completion()
    }
    
    func doSomething() {
        print("Doing something")
    }
    
    deinit {
        print("MyViewController deinit")
    }
}

解决方案：将 [weak self] 放在最外层

在最外层的闭包使用 [weak self]，可以确保所有内部的闭包都使用到弱引用的self：

class MyViewController: UIViewController {
    var myBlock: (() -> Void)?

    override func viewDidLoad() {
        super.viewDidLoad()
        
        myBlock = { [weak self] in
            guard let self = self else { return }
            self.someMethod {
                self.anotherMethod {
                    self.doSomething()
                }
            }
        }
    }
    
    func someMethod(completion: @escaping () -> Void) {
        completion()
    }
    
    func anotherMethod(completion: @escaping () -> Void) {
        completion()
    }
    
    func doSomething() {
        print("Doing something")
    }
    
    deinit {
        print("MyViewController deinit")
    }
}

3.3. 子视图的delegate未释放

问题解释

当一个视图控制器（ViewController）作为某个子视图的delegate时，如果没有在适当的时候将delegate置为nil，该视图控制器就会一直被持有，导致无法释放内存。

代码示例

以下代码展示了子视图的delegate未释放问题：

class MyViewController: UIViewController, UITableViewDelegate {
    var tableView: UITableView!

    override func viewDidLoad() {
        super.viewDidLoad()
        
        tableView = UITableView()
        tableView.delegate = self
    }
    
    // 错误示例，没有在合适的地方将delegate置为nil
    // 这会导致视图控制器无法释放
}

解决方案：在 viewDidDisappear 中将 delegate 置为 nil

在适当的生命周期方法中将delegate置为nil，可以避免内存泄漏：

class MyViewController: UIViewController, UITableViewDelegate {
    var tableView: UITableView!

    override func viewDidLoad() {
        super.viewDidLoad()
        
        tableView = UITableView()
        tableView.delegate = self
    }
    
    override func viewDidDisappear(_ animated: Bool) {
        super.viewDidDisappear(animated)
        tableView.delegate = nil
    }
    
    deinit {
        print("MyViewController deinit")
    }
}

3.4. 子视图互相引用问题

问题解释

当子视图之间互相引用时，会导致循环引用，从而无法释放内存。例如，一个子视图持有另一个子视图的引用，同时另一个子视图也持有第一个子视图的引用。

代码示例

以下代码展示了子视图互相引用的问题：

class ChildView: UIView {
    var parentView: MyViewController?

    func setup(parentView: MyViewController) {
        self.parentView = parentView
    }
    
    deinit {
        print("ChildView deinit")
    }
}

class MyViewController: UIViewController {
    var childView: ChildView!

    override func viewDidLoad() {
        super.viewDidLoad()
        
        childView = ChildView()
        childView.setup(parentView: self)
        view.addSubview(childView)
    }
    
    deinit {
        print("MyViewController deinit")
    }
}

解决方案：使用Block避免互相拥有

可以通过使用Block来避免循环引用问题：

class ChildView: UIView {
    var actionBlock: (() -> Void)?

    func setupActionBlock(block: @escaping () -> Void) {
        self.actionBlock = block
    }
    
    deinit {
        print("ChildView deinit")
    }
}

class MyViewController: UIViewController {
    var childView: ChildView!

    override func viewDidLoad() {
        super.viewDidLoad()
        
        childView = ChildView()
        childView.setupActionBlock { [weak self] in
            self?.doSomething()
        }
        view.addSubview(childView)
    }
    
    func doSomething() {
        print("Doing something")
    }
    
    deinit {
        print("MyViewController deinit")
    }
}

3.5. 未正确释放子视图导致的整体视图无法释放

问题解释

如果一个视图控制器中的子视图未能正确释放，则整个视图控制器也无法被释放。这通常是由于子视图中持有对父视图控制器的强引用。

代码示例

以下代码展示了未正确释放子视图导致的内存泄漏问题：

class MyViewController: UIViewController {
    var childView: UIView?

    override func viewDidLoad() {
        super.viewDidLoad()
        
        childView = UIView()
        view.addSubview(childView!)
    }
    
    // 错误示例，没有在合适的地方将childView释放
}

解决方案：确保所有子视图都能正确释放

在视图控制器的deinit方法中，将所有的子视图都正确释放：

class MyViewController: UIViewController {
    var childView: UIView?

    override func viewDidLoad() {
        super.viewDidLoad()
        
        childView = UIView()
        view.addSubview(childView!)
    }
    
    deinit {
        childView?.removeFromSuperview()
        childView = nil
        print("MyViewController deinit")
    }
}

3.6. 自引用问题

问题解释

当一个对象（如视图控制器）在其内部持有对自身的强引用时，会导致内存泄漏。例如，定时器或通知中心等异步任务在持有对self的强引用时，会导致self无法被释放。

代码示例

以下代码展示了自引用问题：

class MyViewController: UIViewController {
    var timer: Timer?

    override func viewDidLoad() {
        super.viewDidLoad()
        
        timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { _ in
            self.doSomething() // 这里的self被Timer强引用，导致内存泄漏
        }
    }
    
    func doSomething() {
        print("Doing something")
    }
    
    deinit {
        timer?.invalidate()
        print("MyViewController deinit")
    }
}

解决方案：使用 [weak self] 或 [unowned self]

通过使用 [weak self] 或 [unowned self]，可以避免自引用问题：

class MyViewController: UIViewController {
    var timer: Timer?

    override func viewDidLoad() {
        super.viewDidLoad()
        
        timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
            self?.doSomething()
        }
    }
    
    func doSomething() {
        print("Doing something")
    }
    
    deinit {
        timer?.invalidate()
        print("MyViewController deinit")
    }
}

4. 结论

  • 重要性总结：内存管理在iOS开发中至关重要。正确的内存管理可以提高应用的性能和稳定性，提供更好的用户体验。
  • 最佳实践：在使用闭包时要小心避免循环引用，及时释放子视图和delegate，避免自引用问题。通过遵循这些最佳实践，可以有效地避免内存泄漏问题。

通过这些详细的解释和代码示例，读者应该能够理解并解决常见的内存泄漏问题，提高iOS应用程序的稳定性和性能。

avatar
文章
阅读
粉丝