Creating an awaitable lock for C++ PPL tasks

The C# language (well, more accurately, the BCL) has the Reader­Writer­Lock­Slim class which has a Wait­Async method which returns a task that completes asynchronously when the lock has been acquired. I needed an equivalent for the Parallel Patterns Library (PPL), and since I couldn't find one, I ended up writing one. (If you can find one, please let me know!)

// AsyncUILock is a nonrecursive lock that can be waited on
// asynchronously from a UI thread.
class AsyncUILock
{
public:
  Concurrency::task<void> WaitAsync()
  {
    std::lock_guard<std::mutex> guard(mutex);
    if (!locked) {
      // Lock is available. Acquire it.
      locked = true;
      return completed_apartment_aware_task();
    }

    // Lock is not available.
    return completed_apartment_aware_task()
      .then([captured_completion = completion] {
      // Wait for it to become available.
      return Concurrency::create_task(captured_completion);
    }).then([this] {
      // Then try again.
      return WaitAsync();
    });
  }

  void Release()
  {
    std::lock_guard<std::mutex> guard(mutex);
    locked = false;
    auto previousCompletion = completion;
    completion = Concurrency::task_completion_event<void>();
    previousCompletion.set();
  }

private:
  std::mutex mutex;
  bool locked = false;
  Concurrency::task_completion_event<void> completion;
};

The object consists of a std::mutex which protects the internal state, a flag that indicates whether the object has been claimed, and a task completion event that we use to signal anybody waiting on the lock that they should check again.

I could have used an SRWLock instead of a std::mutex, but I was lazy and wanted to take advantage of the existing std::lock_guard.

You can perform async waits on this object in the usual manner. For example:

AsyncUILock lock;

void DoSomething()
{
  lock.WaitAsync().then([]{
    // do something with the lock held.
    lock.Release();
  });
}

or if you prefer co_await (and you probably do):

AsyncUILock lock;
void DoSomething()
{
  co_await lock.WaitAsync();
  // do something with the lock held.
  lock.Release();
}
,/PRE>

At this point, you might decide to return an RAII type
to ensure that the lock doesn't leak.
I'll leave that as an exercise.