Get the Preplance app for a seamless learning experience. Practice offline, get daily streaks, and stay ahead with real-time interview updates.
Get it on
Google Play
4.9/5 Rating on Store
Swift · Question Set
Memory Management & Concurrency interview questions for placements and exams.
Questions
10
Included in this set
Subject
Swift
Explore more sets
Difficulty
Mixed
Level of this set
Go through each question and its explanation. Use this set as a focused practice pack for Swift.
In Swift, `weak` references do not increase the reference count and are always optional, becoming nil when the referenced object is deallocated. `unowned` references also do not increase the count but are non-optional and assume the referenced object will outlive the reference; using unowned after deallocation leads to a crash.
For complete preparation, combine this set with full subject-wise practice for Swift. You can also explore other subjects and sets from the links below.
A retain cycle happens when object A holds a strong reference to object B, and object B holds a strong reference to object A (directly or indirectly). Since neither reference count drops to zero, the objects are never deallocated, causing a memory leak. Identifying and breaking such cycles is important for efficient Swift apps.
When you capture `self` strongly in a closure that the instance holds (for example a callback), you can create a retain cycle: the instance holds the closure, the closure holds `self`. Using `[weak self]` breaks the strong cycle by capturing `self` weakly so it can be deallocated when no longer used. This is a key memory-management technique in Swift.
Concurrency in Swift (as in other languages) introduces pitfalls such as race conditions when multiple threads access shared state without synchronization; deadlocks when tasks wait on each other; priority inversion where a high-priority task is blocked by a lower-priority one; and thread explosion or resource exhaustion when too many concurrent tasks are spawned. /n/n To mitigate these you should use safe concurrency constructs: `actor` types to isolate state, `DispatchQueue` with proper QoS and priority management, `Task` and structured concurrency for async/await, avoid shared mutable state or protect it via locks or barriers, prefer immutable data where possible, and profile using Instruments and the Thread Sanitizer. Recognizing and discussing these in an interview shows you are prepared for real-world Swift development.
Automatic Reference Counting (ARC) in Swift automatically tracks how many references a class instance has. When the count drops to zero, ARC deallocates the instance. This helps manage memory without a garbage collector.
In Swift and iOS development you use `DispatchQueue.main` to execute work on the main thread, especially UI updates. `DispatchQueue.global()` (or other background queues) is used to run tasks off the main thread to maintain responsiveness. Proper use of concurrency avoids UI freezes and ensures performance.
A race condition occurs when concurrent operations access or modify the same data without coordination, leading to inconsistent or unexpected behaviour. In Swift you must ensure thread-safety, typically using serial queues, locks, or other concurrency primitives.
Swift’s `actor` type is designed to safely manage mutable state in concurrent environments by isolating state and guaranteeing safe access across asynchronous tasks. It’s part of Swift’s concurrency model combining async/await with structured concurrency. This is a modern topic in iOS and Swift interviews.
Structured concurrency in Swift is an approach to manage asynchronous work by creating tasks in a well-scoped manner. /n/n Using `async` functions and the `await` keyword you can execute asynchronous code sequentially in appearance while allowing concurrency behind the scenes. Tasks can be created via `Task { … }` or `Task.detached { … }`, and they respect cancellation and lifetimes tied to their parent tasks. /n/n Actors are types that encapsulate mutable state, providing isolation and safe concurrency when accessed via `await`. Combining async/await, tasks and actors leads to safer code by avoiding manual thread management, race conditions and deadlocks. Structured concurrency offers better readability, predictable lifecycle and cancellation support, aligning with modern Swift interview topics.
In Swift value types (structs, enums) do not use ARC. When you assign or pass a value type, it is copied (or optimized by the compiler) and you get independent instances. This means you don’t worry about reference counts or retain cycles for value types. /n/n Reference types (classes) are managed by ARC: each instance has a reference count increased by strong references. When the count drops to zero the instance is deallocated, but retain cycles or misuse of strong references can keep them alive unexpectedly. Understanding this difference helps you design types that are safe and efficient, avoiding memory leaks and unintended sharing of mutable state.