How do I serialize access to all Void returning functions of a class (avoiding race conditions)?

Question

Suppose a class that's arranged something like this:

class A {
    func a() {
        doStuff()
    }
    func b() {
        Task {
            something()
            await someLongRunningThing()
            somethingElse()
        }
    }
    func c() {
        doOtherStuff()
    }
}

How can I make sure that only one function is ever active at a time and that the execution of each function is in a FIFO manner? This would include the body of the Task in b(). If that Task is executing, none of the other functions of the class should be able to be entered and they would queue up and operate FIFO with no interleaving.

Since the member functions will probably be called on the main thread, there should be no blocking of a thread involved.

This is a common scenario I face, and I can't think of a reasonable solution. At first I was excited about actor, but the actor allows reentry when there's an await in a function, allowing race conditions. The only thing I can find about this is here. But here, the author really just pushes the problem further up the call hierarchy.

Answer 1

How about: class A has its own serial queue and your functions submit all their work to it, each as one block. That gets you FIFO processing. If Task isn't inline, then b()'s block can use some synchronization (enter/leave?) to hold the private queue until task completion.

Since all three functions only dispatch and return, their caller's thread isn't blocked.

Answer 2

Here is what I came up with. I don't think about terminating the stream as in my case I didn't need to.

class ActionQueue {
    typealias Action = () async -> Void
    
    func enqueue(action: @escaping Action) {
        DispatchQueue.main.async { [weak self] in
            guard let sself = self else { return }
            if let enqueueAction = sself.enqueueAction {
                enqueueAction(action)
            } else {
                sself.initialQueue.append(action)
            }
        }
    }
    
    private var enqueueAction: ((@escaping Action) -> Void)? = nil
    
    //necessary because the AsyncStream build block doesn't necessary happen
    //on main thread. Otherwise we could lose Actions.
    private var initialQueue = [Action]()
    
    private var stream: AsyncStream<Action> {
        AsyncStream { continuation in
            DispatchQueue.main.sync {
                enqueueAction = { action in
                    continuation.yield(action)
                }
                initialQueue.forEach { action in
                    enqueueAction!(action)
                }
            }
        }
    }
    
    init() {
        Task.init {
            for await action in stream {
                await action()
            }
        }  
    }
}

Usage:

class A {
    
    func a() {
        actionQueue.enqueue {
            doOtherStuff()
        }
    }
    
    func b() {
        actionQueue.enqueue {
            something()
            await someLongRunningThing()
            somethingElse()
            await MainActor.run {
                mustBeOnMainThread()
            }
        }
    }
  
    private let actionQueue = ActionQueue()
}

Answer 3

You can’t under those conditions. It’s a contradiction to spawn work (Task {}) on a function that runs on the main thread, to execute the function fully before another is called, and have no blocking.

If you make it an actor, only one function will be active at a time, but given that you added a suspension point (await) there can be actor reentrancy (scheduling more work on an actor that already has suspended work items). This is also a feature to avoid priority inversion.

While it doesn’t have compiler support under the new concurrency model, it is OK to use NSLock or os_unfair_lock to implement your own synchronization. This would give you a FIFO class but you still would have to schedule its results on Main.

Maybe someone can suggest a better solution if you post a more realistic example of what you are trying to accomplish.