What is a run loop in iOS?

Run loop is a fundamental mechanism in iOS that manages incoming events and task scheduling. It is an infinite loop that waits for input (events) and triggers the appropriate handlers. Each thread, including the main user interface thread, has its own run loop.

Main components of run loop:

• Input Sources: Generate asynchronous events, such as screen touches, network responses, timer triggers.
• Timers: Generate synchronous events at specified times.
• Run Loop Observers: Receive notifications about various run loop activities (e.g., when the run loop is about to sleep or is processing an event).

Run Loop Modes:

Run loop can operate in different modes, which determine which input sources and timers are monitored. The most common modes are:

• defaultMode: The default mode, used for most tasks.
• trackingMode: Used when tracking user input (e.g., scrolling).

How run loop works:

1. The run loop enters a sleeping state, waiting for events from input sources or timers.
2. When an event occurs or a timer fires, the run loop wakes up.
3. The run loop processes the event or calls the corresponding timer function.
4. If there are observers, the run loop can send notifications about the current status.
5. After processing, the run loop can go back to sleep or continue processing other events.

Importance of run loop in iOS development:

• UI Responsiveness: The main run loop handles UI events. Blocking it (e.g., performing long operations on the main thread) causes the UI to become unresponsive.
• Concurrency: Although the run loop operates within a single thread, having a run loop in each thread allows managing how the thread processes tasks and events.
• Task Scheduling: Timers enable scheduling tasks to run after certain intervals or at specific times.

Example of using run loop (manually, on a secondary thread):

Typically, the main thread's run loop is managed automatically by the system. On secondary threads, it can be started manually, for example, if the thread needs to wait for network events.

import Foundation

class MyWorker {
    func doWork() {
        print("Worker thread started")

        // Adding an input source to keep the run loop alive
        // In this example, just for demonstration
        let source = CFRunLoopSourceCreateWithHandler(kCFAllocatorDefault, 0, nil, nil) { _ in
            print("Run loop source triggered")
        }

        if let runLoop = CFRunLoopGetCurrent(), let source = source {
            CFRunLoopAddSource(runLoop, source, CFRunLoopMode.defaultMode)

            // Starting the run loop in default mode
            // The run loop will run until it is stopped or sources are exhausted
            CFRunLoopRun()

            // This code executes only after CFRunLoopStop()
            print("Worker thread finished")
        }
    }
}

// Example of creating and starting a thread
let workerThread = Thread {
    MyWorker().doWork()
}
workerThread.start()

// To demonstrate stopping the run loop (a different mechanism is needed in real applications)
// DispatchQueue.global().asyncAfter(deadline: .now() + 2) {
//     if let runLoop = CFRunLoopGetCurrent() {
//         CFRunLoopStop(runLoop)
//     }
// }