Closures causing retain cycles in Swift - Mini Project: Build & Apply

Closures Causing Retain Cycles in Swift

📖 Scenario: Imagine you are building a simple app where a Person has a closure property that prints their name. You want to understand how closures can cause retain cycles, which means the Person and the closure keep each other alive and never get removed from memory.

🎯 Goal: You will create a Person class with a closure property that captures self. Then, you will add a configuration variable to control whether to use a capture list to avoid retain cycles. Finally, you will observe the output to understand when retain cycles happen.

📋 What You'll Learn

Create a Person class with a name property and a closure property called printNameClosure.

Add a Boolean variable useCaptureList to decide if the closure captures self weakly.

Write the closure inside the Person initializer using useCaptureList to avoid or cause retain cycles.

Print messages when the Person instance is deinitialized to observe retain cycles.

💡 Why This Matters

🌍 Real World

Understanding retain cycles is important when building iOS apps to prevent memory leaks that slow down or crash apps.

💼 Career

Swift developers must manage memory carefully. Knowing how closures capture references helps write efficient and safe code.

1

Create the Person class with name and closure

Create a class called Person with a name property of type String. Add a closure property called printNameClosure of type () -> Void. Initialize printNameClosure as an empty closure in the class.

Swift

class Person {
    var name: String
    var printNameClosure: () -> Void = {}
    
    // Your code here
}

Hint

Define the class with name and printNameClosure. Initialize printNameClosure as an empty closure.

2

Add a configuration variable to control capture behavior

Add a Boolean variable called useCaptureList to the Person class. Initialize it in the init method with a default value of false.

Swift

class Person {
    var name: String
    var printNameClosure: () -> Void = {}
    var useCaptureList: Bool
    
    init(name: String, useCaptureList: Bool = false) {
        self.name = name
        self.useCaptureList = useCaptureList
        // Your code here
    }
}

Hint

Add useCaptureList as a property and initialize it in the constructor with a default false.

3

Set the closure with or without weak capture of self

Inside the init method, assign printNameClosure a closure that prints the name. Use useCaptureList to decide if the closure captures self weakly with [weak self] or strongly without a capture list.

Swift

class Person {
    var name: String
    var printNameClosure: () -> Void = {}
    var useCaptureList: Bool
    
    init(name: String, useCaptureList: Bool = false) {
        self.name = name
        self.useCaptureList = useCaptureList
        if useCaptureList {
            // Your code here
        } else {
            // Your code here
        }
    }
}

Hint

Use [weak self] in the closure capture list when useCaptureList is true. Otherwise, capture self strongly.

4

Create and test Person instances to observe retain cycles

Create a function called testPerson that creates a Person instance named person with name "Alice" and useCaptureList set to false. Call person.printNameClosure(). Then set person to nil. Print "Person instance is set to nil" after. Add a deinit method in Person that prints "Person \(name) is being deinitialized". Run testPerson() and observe the output.

Swift

class Person {
    var name: String
    var printNameClosure: () -> Void = {}
    var useCaptureList: Bool
    
    init(name: String, useCaptureList: Bool = false) {
        self.name = name
        self.useCaptureList = useCaptureList
        if useCaptureList {
            printNameClosure = { [weak self] in
                if let strongSelf = self {
                    print("Name is \(strongSelf.name)")
                } else {
                    print("Person no longer exists")
                }
            }
        } else {
            printNameClosure = {
                print("Name is \(self.name)")
            }
        }
    }
    
    // Your code here
}

func testPerson() {
    // Your code here
}

testPerson()

Hint

Create a testPerson function that creates and uses a Person instance, then sets it to nil. Add a deinit method to observe deinitialization.

Practice

1. What is the main reason closures cause retain cycles in Swift?

easy

A. Closures capture self strongly, preventing deallocation

B. Closures do not capture variables at all

C. Closures always run on a background thread

D. Closures automatically break retain cycles

Solution

1. Step 1: Understand closure capturing behavior

   Closures in Swift capture variables, including self, strongly by default.

2. Step 2: Recognize impact on memory

   If a closure captures self strongly and self holds the closure, neither can be released, causing a retain cycle.

3. Final Answer:

   Closures capture self strongly, preventing deallocation -> Option A

4. Quick Check:

   Strong capture causes retain cycle = B [OK]

Hint: Closures keep strong references by default, causing retain cycles [OK]

Common Mistakes:

• Thinking closures do not capture variables
• Assuming closures run on background threads
• Believing closures automatically break retain cycles

2. Which of the following is the correct syntax to declare a closure capturing self weakly in Swift?

easy

A. let closure = { weak self in print(self) }

B. let closure = { (weak self) -> Void in print(self) }

C. let closure = { [weak self] in print(self) }

D. let closure = { [self weak] in print(self) }

Solution

1. Step 1: Recall capture list syntax

   In Swift, capture lists are declared inside square brackets before the closure body.

2. Step 2: Identify correct weak capture syntax

   The correct syntax is [weak self] inside the capture list, followed by the closure code.

3. Final Answer:

   let closure = { [weak self] in print(self) } -> Option C

4. Quick Check:

   Capture list uses [weak self] = C [OK]

Hint: Use square brackets for capture lists like [weak self] [OK]

Common Mistakes:

• Using parentheses instead of brackets for capture list
• Writing weak self without brackets
• Swapping order to [self weak]

3. Consider this Swift code snippet:

class MyClass {
    var closure: (() -> Void)?
    func setup() {
        closure = {
            print(self)
        }
    }
}
let obj = MyClass()
obj.setup()

What is the main problem with this code?

medium

A. It runs without any memory issues

B. It causes a syntax error due to missing capture list

C. It prints nil because self is not captured

D. It causes a retain cycle because closure captures self strongly

Solution

1. Step 1: Analyze closure capturing self

   The closure assigned to the property captures self strongly by default.

2. Step 2: Understand retain cycle effect

   Since self holds closure and closure holds self, neither is released, causing a retain cycle and memory leak.

3. Final Answer:

   It causes a retain cycle because closure captures self strongly -> Option D

4. Quick Check:

   Strong capture causes retain cycle = A [OK]

Hint: Closures capturing self strongly cause retain cycles unless weak/unowned used [OK]

Common Mistakes:

• Assuming no retain cycle without capture list
• Thinking it causes syntax error
• Believing closure prints nil

4. Given this code, what is the best fix to avoid the retain cycle?

class ViewController {
    var completion: (() -> Void)?
    func configure() {
        completion = {
            print(self)
        }
    }
}

medium

A. Call configure() twice

B. Use [weak self] in the closure capture list

C. Declare completion as a strong reference

D. Remove the closure property entirely

Solution

1. Step 1: Identify cause of retain cycle

   The closure captures self strongly, causing retain cycle with the property.

2. Step 2: Apply weak capture to break cycle

   Adding [weak self] in the capture list makes self a weak reference, breaking the cycle.

3. Final Answer:

   Use [weak self] in the closure capture list -> Option B

4. Quick Check:

   Weak capture breaks retain cycle = D [OK]

Hint: Add [weak self] to closure capture list to fix retain cycles [OK]

Common Mistakes:

• Removing closure property instead of fixing capture
• Making completion strong reference (already strong)
• Calling configure multiple times doesn't fix cycle

5. You have a class with a closure property that captures self unowned:

class Worker {
    var task: (() -> Void)?
    func start() {
        task = { [unowned self] in
            print("Working with \(self)")
        }
    }
}
var w: Worker? = Worker()
w?.start()
w = nil

What happens when w is set to nil and why?

hard

A. Worker instance is deallocated safely; unowned does not retain self

B. Runtime crash occurs because closure accesses deallocated self

C. Memory leak occurs due to strong capture

D. Nothing happens; closure is never called

Solution

1. Step 1: Understand unowned capture behavior

   Unowned references do not increase retain count but expect self to exist while closure runs.

2. Step 2: Analyze deallocation when w = nil

   Setting w to nil releases Worker instance; no retain cycle exists because closure holds unowned self.

3. Final Answer:

   Worker instance is deallocated safely; unowned does not retain self -> Option A

4. Quick Check:

   Unowned capture allows safe deallocation = A [OK]

Hint: Unowned captures don't retain but expect self alive during use [OK]

Common Mistakes:

• Confusing unowned with weak causing runtime crash
• Assuming strong capture causes leak here
• Thinking closure runs automatically on deallocation