Swift iOS interview questions and answers – Part 3 – Threading & concurrency

Uplift iOS Interview

The Guide is for YOU if
  • You are preparing for an iOS interview and want to improve your skills and knowledge and looking to level up your interview game and land your dream job.
  • You want to gain confidence and ease during iOS interviews by learning expert tips and curated strategies.
  • You want access to a comprehensive list of iOS interview QA to practice and prepare.

Part 3 consists Swift iOS interview questions and answers of thread and concurrency. It will cover concurrency-related topics such as GCD, NSOperation, operation queue, lock, semaphore etc. Threading and concurrency are important concepts in software development and are especially relevant in mobile development, where limited processing power and battery life are major concerns. For this reason, they are often included in technical interviews for senior iOS developers.

In iOS development, understanding threading and concurrency is crucial for building responsive and efficient applications. An iOS developer should be familiar with the various tools and techniques available for managing concurrent tasks, such as Grand Central Dispatch (GCD) and Operation Queues, and know how to use them to optimize the performance and responsiveness of an application. The ability to understand and address race conditions, deadlocks, and other synchronization issues is an important skill for a senior iOS developer. This includes understanding the use of locks, semaphores, and other synchronization mechanisms, as well as the implications of multithreaded programming on the overall architecture and design of an application. Asking about threading and concurrency in an interview for an iOS developer position is meant to assess the candidate’s ability to create performant and scalable applications and to handle the complexities that arise from multithreaded programming.

What is GCD?

GCD is a library that provides a low level and object based API to run tasks concurrently while managing threads behind the scenes. GCD abstracts away thread management code and moves it down to the system level, exposing a light API to define tasks and execute them on an appropriate dispatch queue. 

What is dispatch queue?

A dispatch queue is responsible for executing a task in the FIFO order.

Explain main thread and it’s usages

The main thread in iOS refers to the primary thread of execution for an application. It is responsible for handling user interface events and updates, and running critical tasks such as updating animations and processing user input. In iOS, all UI-related updates and events must occur on the main thread.

This is because the UIKit framework, which provides the core components for building user interfaces in iOS, is not thread-safe and can only be accessed from the main thread. This ensures that the user interface remains responsive and stable, even when executing complex background tasks.

Using the main thread correctly is crucial for the stability and performance of an iOS app. If the main thread becomes blocked for a long period of time, the user interface may become unresponsive, and the app may even crash. Therefore, it is important to minimize the amount of work performed on the main thread and to use background threads for CPU-intensive tasks.

What is serial queue?

The serial queue can run tasks one at a time and it needs to wait for the started tasks to finish.

What is concurrent queue?

The concurrent queue can run as many tasks as it can without waiting for the started tasks to finish.

Explain GCD queues

GCD (Grand Central Dispatch) is a technology used in Apple’s macOS and iOS operating systems for managing concurrent operations. It provides a way to run tasks asynchronously on different threads and helps manage the dispatch of tasks to different processing resources.

GCD queues are the main mechanism for executing tasks in GCD. They can be thought of as a collection of tasks to be executed and are used to manage the order in which tasks are executed and the number of tasks that can be executed simultaneously. Tasks can be added to a queue, and then the queue executes those tasks in the order in which they were added. There are two types of queues in GCD: serial and concurrent. A serial queue runs tasks one at a time in the order in which they were added, while a concurrent queue can run multiple tasks simultaneously.

GCD provides three instances of queues that are on use in iOS.

Main queue: Serial queue – It runs on the main thread.
Global queue: Concurrent queue – It runs with different priorities and is shared by the entire system.
Custom queue: Serial/ Concurrent queue.

What is GCD’s Quality of Service?

Quality of Service is the priority to perform task in GCD. If the task has higher quality of service than other it will be handled before lower quality of service.

Quality of Services are ranked from highest to lowest –

User Interactive: Work that happens on the main thread, such as animations or drawing operations.
User Initiated: Work that the user kicks off and should yield immediate results. This work must be completed for the user to continue.
Utility: Work that may take a bit and doesn’t need to finish right away. Analogous to progress bars and importing data.
Background: This work isn’t visible to the user. Backups, syncs, indexing, etc.

What is race condition?

A race condition is a situation in which the behavior of a software system is dependent on the relative timing of events, such as the order in which threads or tasks are executed. In iOS, a race condition can occur when multiple threads or tasks attempt to access or modify the same data simultaneously, leading to unexpected or incorrect results.

For example, imagine two threads both attempting to increment the same variable. If both threads access the variable at the same time, increment its value, and then store the result, the variable may end up with an incorrect value, because the order in which the increments are executed is not guaranteed. This is an example of a race condition.

Race conditions can be difficult to detect and debug, as they may not occur consistently or predictably. To avoid race conditions in iOS, it’s important to use synchronization techniques such as locks, semaphores, or atomic operations to ensure that data is accessed and modified in a controlled manner.

What is priority inversion?

Priority inversion is a critical condition in threading where a low priority thread blocks a high priority thread from executing and make the assigned priorities meaningless for the thread.

What is deadlock?

A deadlock occurs when two or sometimes more tasks wait for the other to finish, and neither ever does.

What is async-await in Swift?

Async-await is a programming pattern that allows you to write asynchronous code in a more readable and concise way in Swift. It was introduced in Swift 5.5 and is built on top of Swift’s existing concurrency features.

With async-await, you can write asynchronous code as if it were synchronous. This means you can write code that looks and behaves like normal synchronous code, but behind the scenes, it’s actually executing asynchronously.

func fetchData() async throws -> Data {
  let url = URL(string: "https://example.com/data")!
  let (data, _) = try await URLSession.shared.data(from: url)
  return data

func printData() async {
  do {
    let data = try await fetchData()
    print(String(data: data, encoding: .utf8)!)
  } catch {
    print("Error: \(error)")

Task { await printData() }

Here, We have two functions: fetchData and printData. fetchData is an asynchronous function that fetches data from a URL using URLSession. printData is also an asynchronous function that calls fetchData and prints the result. To call an asynchronous function, we use the await keyword. When we call fetchData from printData, we use await to wait for the function to complete before continuing execution. If an error is thrown, we handle it using a do-catch block.

We create a new Task and call printData using await to ensure that the function has finished executing before the program exits.

What problems do async-await and Combine framework solve?

Async-await and Combine framework solve similar kind of problems, namely the handling of asynchronous operations. However, async-await offers a more concise and readable way to write asynchronous code, while Combine provides a powerful reactive programming framework that can be used to handle streams of data.

One of the main problems that async-await solves in the context of callback-based implementation is the issue of callback hell. In traditional callback-based code, it’s common to have nested callbacks, which can quickly become difficult to read and maintain.

With async-await, you can write asynchronous code that looks and behaves like synchronous code, avoiding the need for nested callbacks and improving code readability.

Combine, on the other hand, provides a way to handle streams of data in a more reactive way. Rather than making explicit callbacks to update UI or handle data, Combine provides a set of operators that allow you to manipulate and transform streams of data as they are emitted.

This can make it easier to handle complex asynchronous operations, such as handling network requests or processing large amounts of data.

To sum up, async-await and Combine are two options for managing asynchronous tasks in Swift, but they address distinct challenges. Async-await presents a clearer and more compact approach to writing asynchronous code, whereas Combine presents a reactive programming infrastructure for managing data streams.

What is concurrency and time slicing?

Concurrency is the structural way to run multiple tasks at the same time. Time slicing is used to provide concurrency in a single core device. In case of using time slicing in single core device – one thread will run on specific time and perform a context switch, then another thread will run. Multi-core devices can run multiple threads at the same time via parallelism.

What is NSOperation?

NSOperation is built on top of GCD. While using NSOperation developer can add dependency among various operations and re-use, cancel and suspend operations. Of course the same thing can also be archived through GCD but it will add extra overhead.

What is NSBlockOperation?

NSBlockOperation helps you to implement the NSOperation from one or more closures. NSBlockOperations can have multiple blocks, that can run concurrently.

What is ThreadPool?

ThreadPool is a pool of threads that reuses a fixed number of threads to execute the specific task.

What is used to sleep a thread?

sleep(forTimeInterval:) sleeps the thread for a given time interval.

Explain concurrency vs parallelism

Concurrency is when two or more tasks can start, run, and complete in overlapping time periods. It doesn’t necessarily mean they’ll ever both be running at the same instant.

Parallelism is when tasks literally run at the same time.

This talk of Rob Pike is very helpful to understand the concept.

What is semaphore?

Semaphores gives us the ability to control access to a shared resource by multiple threads. A semaphore consist of a threads queue and a counter value. Counter value is used by the semaphore to decide if a thread should get access to a shared resource or not. The counter value changes when we call signal() or wait() functions.

What is Task?

The task is introduced in the concurrency framework at WWDC 2021. By using a task we can simply create a concurrent context from a non-concurrent method, calling methods using async/await. There is a lot of similarity between dispatch queues and tasks and tasks seem more developer-friendly with less code. Both task and dispatch queue can serve some work on a different thread with a default/user-defined priority.

What is Actor?

Actor in Swift works like a thread-safe class that can be used safely in a concurrent environment. The swift compiler ensures that no section of the code from a different thread could not get access to Actor’s data at the same time. This approach enforced safety by default without writing boilerplate code using semaphore/Lock.

What is TaskGroup?

The task group in swift is a collection of tasks that work together to produce a result. Each task inside the task group can generate the partial result data which will be used to generate an expected result. A very common example of task group usage is creating a collage by downloading multiple images from the network.

Fellow iOS Developers, Please Keep In Mind

  • It’s important to keep in mind a few key points as you prepare for your interview. Firstly, it’s worth noting that there are over 1000 interview questions available in the interview section for you to review and prepare for. While reading the question, take the time to carefully consider your answer and think about the information that you want to convey. The answer provided here in this blog can be explained in a different way. You should also prepare your examples.
  • It’s also important to remember that these interview questions are not meant to be difficult. The interviewer is not looking to challenge you, but rather to start a conversation that will allow your abilities and interests to come to the forefront. They want to get to know you and your experience better.
  • Finally, it’s crucial to avoid simply answering questions with a “yes” or “no.” Interviewers are looking for more in-depth responses that include basic understanding, reasoning, explanation, and examples. So, make an effort to elaborate on your answers and provide specific, relevant information to support your response. This will demonstrate your thoughtfulness and show the interviewer that you are well-prepared for the interview.

Swift iOS interview questions and answers

Swift iOS interview questions and answers – Part 1

Swift iOS interview questions and answers – Part 2

Swift iOS interview questions and answers – Part 3

Swift iOS interview questions and answers – Part 4

Swift iOS interview questions and answers – Part 5

SwiftUI Series

SwiftUI Interview Questions & Answers

SwiftUI Interview Questions and Answers – Part 1 – UI Basics

SwiftUI Interview Questions And Answers – Part 3 – Data

Planning to apply for iOS job? Check out this article to uplift your resume! Happy job hunting!

✍️ Written by Ishtiak Ahmed

👉 Follow me on XLinkedIn

Get Ready to Shine: Mastering the iOS Interview

Enjoying the articles? Get the inside scoop by subscribing to my newsletter.

Get access to exclusive iOS development tips, tricks, and insights when you subscribe to my newsletter. You'll also receive links to new articles, app development ideas, and an interview preparation mini book.

If you know someone who would benefit from reading this article, please share it with them.