Dispatch_after – GCD in Swift

This tutorial will focus on the dispatch_after function, which is used to execute a block of code after a specified delay.

Grand Central Dispatch (GCD) is a powerful framework in Swift for writing concurrent code. One common use case is delaying the execution of a block of code.

Basic Usage (Pre-Swift 3)

Here, the tutorial introduces a basic utility function named delay, which simplifies the syntax for using dispatch_after in earlier versions of Swift. The code snippet demonstrates how to define and use this function to execute code after a specified delay.

Example

func delay(delay: Double, closure: () -> ()) {
    dispatch_after(
        dispatch_time(
            DISPATCH_TIME_NOW,
            Int64(delay * Double(NSEC_PER_SEC))
        ),
        dispatch_get_main_queue(), closure)
}

// Example usage:
delay(0.4) {
    // do stuff after 0.4 seconds
}

Explanation:

• This code defines a function delay that takes a delay time in seconds and a closure to execute after the delay.
• Inside the function, dispatch_after is used to schedule the execution of the closure after the specified delay.
• dispatch_time is used to calculate the time in the future based on the current time (DISPATCH_TIME_NOW) and the delay provided.
• The closure is dispatched to the main queue (dispatch_get_main_queue()) for execution after the delay.

Basic Usage (Swift 3+)

In Swift 3 and later, the delay function can be updated to leverage the improvements in syntax. The code snippet below shows the updated version of the delay function for Swift 3 and later.

Example

func delay(_ delay: Double, closure: @escaping () -> ()) {
    let when = DispatchTime.now() + delay
    DispatchQueue.main.asyncAfter(deadline: when, execute: closure)
}

// Example usage:
delay(0.4) {
    // do stuff after 0.4 seconds
}

Explanation:

• This code defines the same delay function but with Swift 3+ syntax.
• DispatchTime.now() + delay calculates the future time when the closure should be executed.
• DispatchQueue.main.asyncAfter is used to schedule the execution of the closure on the main queue after the specified delay.

Understanding dispatch_after Parameters

This section explains the parameters of the dispatch_after function. It breaks down the purpose of each parameter (when, queue, and block) and provides an understanding of their respective types and roles in scheduling the execution of code blocks.

Example

dispatch_after(when: dispatch_time_t, queue: dispatch_queue_t, block: dispatch_block_t?)

Explanation:

• when: Specifies the time after which the block should be executed. It is of type dispatch_time_t, which is a UInt64.
• queue: Specifies the dispatch queue on which the block should be executed. It is of type dispatch_queue_t, which is type-aliased to an NSObject.
• block: Represents the block of code to be executed. In Swift, it is a closure with the type () -> Void.

Example Usage of dispatch_after

The tutorial provides an example usage of the dispatch_after function, highlighting how to create a delay of one second before executing a code block that prints “test”. The code snippet illustrates how to use dispatch_after with its parameters to achieve the desired delayed execution.

Example

let delayTime = dispatch_time(DISPATCH_TIME_NOW, Int64(1 * Double(NSEC_PER_SEC)))
dispatch_after(delayTime, dispatch_get_main_queue()) {
    print("test")
}

Explanation:

• This snippet demonstrates how to use dispatch_after with the pre-Swift 3 syntax.
• dispatch_time is used to calculate the time in the future.
• The closure, print("test"), is executed after the specified delay on the main queue.

Swift 3+ Shortcut

This section introduces a more concise and elegant syntax introduced in Swift 3+ for using dispatch_after. The code snippet demonstrates how to use DispatchQueue.main.asyncAfter with the .now() shorthand and a specified delay to execute a code block after the given delay.

Example

DispatchQueue.main.asyncAfter(deadline: .now() + 4.5) {
    // ...
}

Explanation:

• This snippet showcases the cleaner Swift 3+ syntax for delayed execution.
• DispatchQueue.main.asyncAfter is used to schedule the closure for execution on the main queue after a delay of 4.5 seconds.

Custom Function for Delay in Swift 3+

Finally, the tutorial presents a custom function delayWithSeconds for delaying code execution in Swift 3+. The code snippet shows how to define this function, which encapsulates the DispatchQueue.main.asyncAfter call, making it easier to use for delaying code blocks with specified delays.

Example

func delayWithSeconds(_ seconds: Double, completion: @escaping () -> ()) {
    DispatchQueue.main.asyncAfter(deadline: .now() + seconds) { 
        completion()
    }
}

// Example usage:
delayWithSeconds(1) {
    // Do something after 1 second
}

Explanation:

• This snippet defines a custom function delayWithSeconds that takes a delay time in seconds and a completion closure.
• Inside the function, DispatchQueue.main.asyncAfter is used to execute the completion closure after the specified delay on the main queue.

Conclusion

The conclusion summarizes the usefulness of dispatch_after for introducing delays in code execution, whether using the traditional syntax or the cleaner Swift 3+ syntax, and encourages incorporating delayed execution into Swift code for improved efficiency and responsiveness.