is there a library similar to Reentrant Lock in Java for Swift?

Question

I am currently working on a function that can be used by multiple threads. The issue is that the function needs to complete first and store the result in the cache. In the meantime, other threads could be calling this function and I would need them to wait until is completed. We were able to accomplish this on Java using Reentrant Lock is there a similar library in swift? I saw that NSRecursiveLock approaches what we are trying to do, however, we want to keep it with swift only. I have also been seeing multiple articles such as this one that talks about using GCD, however, I believe this is for something similar but different: https://medium.com/@prasanna.aithal/multi-threading-in-ios-using-swift-82f3601f171c

Thank you in advance.

Answer 1

Recursion with locking is always a bit of a pain point. A clean solution would be to refactor your function that requires the lock into an external API that acquires the lock and forwards to an internal API that doesn't. Internally don't call the external API.

A simple example might be something like this (this is almost Swift code - parameters and actual work implementations need to be filled in)

extension DispatchSemaphore
{
    func withLock<R>(_ block: () throws -> R) rethrows -> R
    {
        wait()
        defer { signal() }
        return try block()
    }
}

let myLock = DispatchSemaphore(value: 1)

func recursiveLockingFunction(parameters)
{
    func nonLockingFunc(parameters) {
        if /* some terminating case goes here */ {
             // Do the terminating case
             return
        }

        // Do whatever you need to do to handle the partial problem and 
        // and reduce the parameters
        nonLockingFunc(reducedParameters)
    }

    myLock.withLock { nonLockingFunc(parameters) }
}

Whether this will work for you depends on your design, but should work if the only problem is that the function you want to lock is recursive. And it only uses GCD (DispatchSemaphore) to achieve it.