Deadlock When Using DispatchQueue from Swift Task

Using Swift
,
31

Consider code like this:

class ThreadsafeCounter {
  var protectedCounter = OSAllocatedUnfairLock(initialState: 0)
  mutating func increment() {
    protectedCounter.withLock { $0 += 1 }
  }
}

increment will block other threads while a thread is in withLock, but no new threads will need to be created or unblocked to unblock them: the thread holding the lock is the one that will do the work, and it already exists and is not blocked. So the worst that will happen in this case is that all but one thread in the thread pool will very briefly wait, reducing your concurrency a little.

You might expect that if the thread holding the lock was very low priority this could be a problem (since instead of waiting briefly they might wait a long time while other high priority work on the system ran), but both DispatchQueue and OSAllocatedUnfairLock know how to avoid that by boosting the priority of the lock-owning thread to the maximum priority of the waiting threads.

What isn't safe is something like this:

class DeadlockProneCounter {
  var protectedCounter = OSAllocatedUnfairLock(initialState: 0)
  mutating func increment() {
    protectedCounter.withLock { state in
      let asyncIncrementer = Task { state += 1 }
      //THIS DOESN'T ACTUALLY EXIST, FOR THIS REASON
      asyncIncrementer.synchronouslyWait()
    }
  }
}

Here's the scenario where it fails, imagining that we're running on a 2 core device for simplicity:

Thread 1: enters increment() and takes lock
Thread 2: enters increment() and begins waiting for lock
Thread 1: spawns a Task, then waits for it
Thread ???: runs the Task… wait, we already have 2 threads on our 2 cores, so there isn't another thread available. All 2 of our 2 threads are waiting.
Threads 1 and 2: wait forever

4 Likes