Swift async / await

Swift 5.5 has brought about a game-changing feature: async/await functionality. This exciting addition allows us to manage asynchronous tasks in a way that feels just as intuitive as working with traditional synchronous functions.

1. Create an Async Function:

To create an async function in Swift, simply use the async keyword in the function's declaration. For example:

func loadData() async -> Data {
 // Asynchronous code to load data 
}        

In the loadData function, you can write asynchronous code to retrieve data, Due to asynchronous task it will not block the main thread. This allows you to load data without freezing your app's user interface, creating a more responsive user experience.

2. How to call an Async Function:

Calling an asynchronous function in Swift involves using the await keyword to pause the current task until the asynchronous operation finishes. Here's how you can use it:

let data = await loadData()        

3. Utilizing Async/Await with Concurrency Tasks:

Swift's concurrency model has introduced a new concept called tasks. These tasks empower us to initiate and oversee the execution of asynchronous functions in the background, enabling us to seamlessly await their results. For example:

Task {
  let data = await loadData()
}        

4. Handling Errors:

You can use try/catch to handle errors that might occur in an asynchronous function. For example:

do { 
  let data = try await loadData() 
  // Use the fetched data 
} catch { 
  print("Error: \(error)") 
}        

5. Async Sequences:

You can work with sequences of asynchronous elements using async sequences. For instance, you can use the for await ... in loop to iterate over asynchronous elements:

async let numbers = [1, 2, 3, 4] 
for try await number in numbers { 
  // Process each number asynchronously 
}        

6. Cancellation:

You can cancel asynchronous tasks using the Task.cancel method. This feature enables you to manage the cancellation of tasks and perform necessary resource cleanup.

7. Task Priorities:

You can assign priorities to tasks using Task(priority:) to control the order in which tasks are executed. Higher-priority tasks get scheduled first. For example

import Foundation

func printMessage(_ message: String) {
? ? print(message)
}

let highPriorityTask = Task(priority: .userInitiated) {
? ? printMessage("High-priority task is running")
}

let lowPriorityTask = Task(priority: .utility) {
? ? printMessage("Low-priority task is running")
}

let defaultPriorityTask = Task(priority: .default) {
? ? printMessage("Default-priority task is running")
}

let defaultPriorityTask = Task(priority: .background) {
? ? printMessage("Background-priority task is running")
}

Task {
? ? await highPriorityTask.value
? ? await lowPriorityTask.value
? ? await defaultPriorityTask.value
? ? await backgroundPriorityTask.value
}
print("All tasks are launched")        

8. Structured Concurrency:

Structured concurrency is a programming paradigm that helps manage concurrency in a more organized and safer way. In the context of Swift, it ensures that asynchronous tasks are properly scoped and managed. Here's a simplified explanation of structured concurrency:

• Task Creation: In structured concurrency, you create tasks for concurrent or asynchronous work. it created within a specific scope, such as a function, a block, or a structured construct like async let.
• Task Lifetime: The tasks you create have a well-defined lifetime tied to the scope in which they were created. When the scope exits, all tasks within that scope are automatically canceled.
• Cancellation: Structured concurrency provides a simple way to cancel tasks when they're no longer needed. This helps avoid resource leaks and unintended task execution.
• Clean Termination: Due to tasks are automatically canceled when their parent scope exits, it finalised that tasks are terminated properly, reducing the risk of resource leaks and dangling references.