Semaphores In Swift

Nausheen Siddiqui

6 September 2024

In concurrent programming, managing shared resources and synchronizing access to them is crucial for maintaining data integrity and preventing race conditions. One powerful synchronization primitive for achieving this is semaphores. Semaphores act as counters that allow a specified number of threads to access a resource simultaneously. In Swift, semaphores are a valuable tool for creating efficient and safe concurrent applications.

A semaphore is essentially a signaling mechanism that controls access to a shared resource. It maintains a counter representing the number of available resources. When a thread requests access to the resource, it checks the semaphore’s counter. If the counter is greater than zero, the thread is granted access, and the counter is decremented. If the counter is zero, the thread is blocked until a resource becomes available.

Benefits of Semaphores:

Semaphores offer several advantages in concurrent programming. They enable fine-grained control over resource access, preventing data races and ensuring thread safety.

Semaphores also allow you to limit the number of concurrent threads, which can be helpful when dealing with limited resources or preventing overwhelming concurrent operations.

Implementation:

Swift provides a built-in Semaphore class, making it straightforward to utilize semaphores in your code. To get started, import the Dispatch module, which includes the necessary APIs. Then, create a semaphore instance with an initial value representing the maximum number of threads that can access the resource simultaneously.

To request access to the resource, call the wait() method on the semaphore. This method decrements the semaphore’s counter and blocks the thread if the counter reaches zero. When finished with the resource, call the signal() method to increment the counter and allow other threads to access the resource.

import Dispatch

let semaphore = DispatchSemaphore(value: 2)

func performTask(_ taskId: Int) {
    semaphore.wait()
    print("Task \(taskId) started")
    // Simulating some task
    Thread.sleep(forTimeInterval: 2)
    print("Task \(taskId) finished")
    semaphore.signal()
}

for i in 1...5 {
    DispatchQueue.global().async {
        performTask(i)
    }
}

// Output:
// Task 1 started
// Task 2 started
// Task 1 finished
// Task 3 started
// Task 2 finished
// Task 4 started
// Task 3 finished
// Task 5 started
// Task 4 finished
// Task 5 finished

import Dispatch

let semaphore = DispatchSemaphore(value: 2)

func performTask(_ taskId: Int) {

semaphore.wait()

print("Task \(taskId) started")

// Simulating some task

Thread.sleep(forTimeInterval: 2)

print("Task \(taskId) finished")

semaphore.signal()

}

for i in 1...5 {

DispatchQueue.global().async {

performTask(i)

}

// Output:

// Task 1 started

// Task 2 started

// Task 1 finished

// Task 3 started

// Task 2 finished

// Task 4 started

// Task 3 finished

// Task 5 started

// Task 4 finished

// Task 5 finished

In this example, we create a semaphore with a value of 2, allowing a maximum of two concurrent tasks to execute. The performTask function represents a task that takes some time to complete. When the semaphore’s counter reaches zero, any additional tasks will be blocked until a task finishes and signals the semaphore.

Conclusion:

In this article, I have explained Semaphores in Swift.

Thanks for reading this article ❤

If I got something wrong 🙈, let me know in the comments. I would love to improve.

Reference Link: https://medium.com/@roykronenfeld/semaphores-in-swift-e296ea80f860

You can also read – https://mobikul.com/integrate-native-sdks-in-a-flutter-project/