What is the difference between asynchronous and multithreading?

Asynchrony is a technique that allows continuing the execution of the main thread while some operation occurs in the background, waiting for its completion without blocking.

Multithreading is the ability of a program to perform multiple parts of its work (threads) simultaneously or pseudo-simultaneously (on single-core processors).

The key difference:

• Multithreading — a way to parallelize task execution using multiple threads.
• Asynchrony — a way to handle operations that require waiting (e.g., I/O, network requests) without blocking the main thread.

Asynchrony can be implemented either using multithreading (for example, through GCD or OperationQueue) or without it (for example, through event loops or coroutines).

Example of using GCD for asynchronous work on another thread:

// Sending a block of code to execute in a background queue
DispatchQueue.global(qos: .background).async {
    // Long operation executed in a background thread
    let result = performBackgroundOperation() 

    // Returning to the main thread to update UI
    DispatchQueue.main.async {
        updateUI(with: result)
    }
}

func performBackgroundOperation() -> String {
    // Simulating a long task
    sleep(2) 
    return "Operation completed"
}

func updateUI(with result: String) {
    // Updating UI elements on the main thread
    print(result)
}