What are retain cycles in iOS?

Reference cycles occur when two or more objects hold strong references to each other, creating a "closed loop." As a result, each object's reference count never reaches zero, and they cannot be released by ARC (Automatic Reference Counting). This leads to memory leaks, as objects remain in memory even after they are no longer needed.

Example:

class Person {
    let name: String
    var apartment: Apartment?

    init(name: String) {
        self.name = name
        print("\(name) is being initialized")
    }

    deinit {
        print("\(name) is being deinitialized")
    }
}

class Apartment {
    let unit: String
    var tenant: Person?

    init(unit: String) {
        self.unit = unit
        print("Apartment \(unit) is being initialized")
    }

    deinit {
        print("Apartment \(unit) is being deinitialized")
    }
}

In this example, if Person has a strong reference to Apartment, and Apartment has a strong reference to Person, then when trying to release these objects, they will not be deallocated because their reference counts do not reach zero.

How to solve reference cycle problems:

Use weak or unowned references.

• weak: Used when the related object may become nil during the lifecycle of the other object. The reference automatically becomes nil when the object it refers to is deallocated. It is an optional.
• unowned: Used when it is known that the related object has the same or a longer lifecycle than the object holding the reference. It cannot be nil.

Modified example using weak:

Change the tenant reference in the Apartment class to weak:

class Apartment {
    let unit: String
    weak var tenant: Person? // Using weak

    init(unit: String) {
        self.unit = unit
        print("Apartment \(unit) is being initialized")
    }

    deinit {
        print("Apartment \(unit) is being deinitialized")
    }
}

Now, when a Person object is deallocated, the tenant reference in Apartment automatically becomes nil, breaking the retain cycle and allowing Apartment to be deallocated as well.

Comparison table of weak and unowned:

Characteristic	weak	unowned
Reference type	Optional	Non-optional
Can be nil?	Yes, when the object is deallocated	No
When to use	When the object may become nil	When the object cannot be nil
Performance	Slightly slower due to nil check	Slightly faster

Cycles can also occur in closures.

When a closure captures instance properties or self, it can create a strong reference to the object. If that object also has a strong reference to the closure (e.g., via a property or delegate), a retain cycle occurs.

How to solve retain cycle issues in closures:

Use a capture list.

class SomeClass {
    var value = 0

    func doSomethingDelayed() {
        DispatchQueue.main.asyncAfter(deadline: .now() + 1) { [weak self] in // Capture list with weak self
            guard let self = self else { return } // Check for nil
            self.value += 1
            print("Value is now \(self.value)")
        }
    }
}

In this example, [weak self] creates a weak reference to self inside the closure, preventing a retain cycle.