camerondm9 / keyedlocks

Sync and async locking based on a key

KeyedLocks

Sync and async locking based on a key

Usage

This library provides the KeyedLock<T> type, which can be used like this:

var locks = new KeyedLock<string>();
using (locks.Lock("key"))
{
    //Do the important thing
}

The using block ensures that the lock will be released after.

In async code, you can also wait to acquire the lock asynchronously:

var locks = new KeyedLock<string>();
using (await locks.LockAsync("key"))
{
    //Do the important thing
}

Testing

KeyedLock<T> is internally based on a Dictionary<T, SemaphoreSlim>. Semaphores are created and destroyed as needed.

This code has been tested with Microsoft Coyote to try to eliminate concurrency bugs.

Changelog

1.0.0

Initial release

keyedlocks's Issues

Potential misuse

Directly returning the KeyedLock.Entry is efficient (no extra GC pressure), but allows for potential misuse if someone keeps a reference to it. They could call Dispose multiple times (or none).

We should probably return a wrapper class instead, so we can throw an exception if Dispose is called a second time.

Not sure what to do if they aren't calling Dispose at all, then their locks will stay locked forever and cause a memory leak...

Alternative: make all fields internal (on KeyedLock.Entry and add an analyzer that warns about putting it in a variable instead of a direct using statement.