Small bugfixes & a new class AsyncMutexLock for async friendly global Mutex

.gitignore

@@ -250,3 +250,5 @@ paket-files/
 # JetBrains Rider
 .idea/
 *.sln.iml
+
+NugetApiKey.txt

AsyncLock.slnx

@@ -0,0 +1,4 @@
+<Solution>
+  <Project Path="AsyncLock/AsyncLock.csproj" />
+  <Project Path="UnitTests/UnitTests.csproj" />
+</Solution>

AsyncLock/AsyncLock.cs

@@ -19,7 +19,7 @@ public class AsyncLock
         internal SemaphoreSlim _retry = new SemaphoreSlim(0, 1);
         private const long UnlockedId = 0x00; // "owning" task id when unlocked
         internal long _owningId = UnlockedId;
-        internal int _owningThreadId = (int) UnlockedId;
+        internal int _owningThreadId = (int)UnlockedId;
         private static long AsyncStackCounter = 0;
         // An AsyncLocal<T> is not really the task-based equivalent to a ThreadLocal<T>, in that
         // it does not track the async flow (as the documentation describes) but rather it is
@@ -93,7 +93,8 @@ internal async Task<IDisposable> ObtainLockAsync(CancellationToken cancellationT
                 // In case of zero-timeout, don't even wait for protective lock contention
                 if (timeout == TimeSpan.Zero)
                 {
-                    _parent._reentrancy.Wait(timeout);
+                    //BUG? _parent._reentrancy.Wait(timeout);
+                    if (!_parent._reentrancy.Wait(timeout)) return null;
                     if (InnerTryEnter(synchronous: false))
                     {
                         // Reset the owning thread id after all await calls have finished, otherwise we
@@ -113,7 +114,8 @@ internal async Task<IDisposable> ObtainLockAsync(CancellationToken cancellationT
                 // We need to wait for someone to leave the lock before trying again.
                 while (remainder > TimeSpan.Zero)
                 {
-                    await _parent._reentrancy.WaitAsync(remainder).ConfigureAwait(false);
+                    //BUG? await _parent._reentrancy.WaitAsync(remainder).ConfigureAwait(false);
+                    if (!await _parent._reentrancy.WaitAsync(remainder).ConfigureAwait(false)) return null;
                     if (InnerTryEnter(synchronous: false))
                     {
                         // Reset the owning thread id after all await calls have finished, otherwise we
@@ -122,12 +124,14 @@ internal async Task<IDisposable> ObtainLockAsync(CancellationToken cancellationT
                         _parent._reentrancy.Release();
                         return this;
                     }
-                    _parent._reentrancy.Release();
+                    //BUG? _parent._reentrancy.Release();
 
                     now = DateTimeOffset.UtcNow;
                     remainder -= now - last;
                     last = now;
-                    if (remainder < TimeSpan.Zero)
+                    //BUG? if (remainder < TimeSpan.Zero)
+                    // <= is correct, cause the loop invariant is remainder > TimeSpan.Zero, and the need to release reentrnacy
+                    if (remainder <= TimeSpan.Zero)
                     {
                         _parent._reentrancy.Release();
                         return null;
@@ -202,7 +206,8 @@ internal IDisposable ObtainLock(CancellationToken cancellationToken = default)
                 // In case of zero-timeout, don't even wait for protective lock contention
                 if (timeout == TimeSpan.Zero)
                 {
-                    _parent._reentrancy.Wait(timeout);
+                    //BUG? _parent._reentrancy.Wait(timeout);
+                    if (!_parent._reentrancy.Wait(timeout)) return null;
                     if (InnerTryEnter(synchronous: true))
                     {
                         _parent._reentrancy.Release();
@@ -219,7 +224,8 @@ internal IDisposable ObtainLock(CancellationToken cancellationToken = default)
                 // We need to wait for someone to leave the lock before trying again.
                 while (remainder > TimeSpan.Zero)
                 {
-                    _parent._reentrancy.Wait(remainder);
+                    //BUG? _parent._reentrancy.Wait(remainder);
+                    if (!_parent._reentrancy.Wait(remainder)) return null;
                     if (InnerTryEnter(synchronous: true))
                     {
                         _parent._reentrancy.Release();
@@ -498,5 +504,34 @@ public bool TryLock(Action callback, TimeSpan timeout)
             }
             return true;
         }
+
+        public Task<IDisposable> LockAsync(TimeSpan timeout)
+        {
+            var @lock = new InnerLock(this, _asyncId.Value, ThreadId);
+            _asyncId.Value = Interlocked.Increment(ref AsyncLock.AsyncStackCounter);
+
+            return @lock.TryObtainLockAsync(timeout)
+                .ContinueWith(state =>
+                {
+                    if (state.Exception is AggregateException ex)
+                    {
+                        ExceptionDispatchInfo.Capture(ex.InnerException!).Throw();
+                    }
+                    var disposableLock = state.Result;
+                    if (disposableLock is null) throw new TimeoutException("LockAsync timed out.");
+                    return disposableLock;
+                });
+        }
+
+        public IDisposable Lock(TimeSpan timeout)
+        {
+            var @lock = new InnerLock(this, _asyncId.Value, ThreadId);
+            // Increment the async stack counter to prevent a child task from getting
+            // the lock at the same time as a child thread.
+            _asyncId.Value = Interlocked.Increment(ref AsyncLock.AsyncStackCounter);
+            var lockDisposable = @lock.TryObtainLock(timeout);
+            if (lockDisposable is null) throw new TimeoutException("TryLock timed out.");
+            return lockDisposable;
+        }
     }
 }

AsyncLock/AsyncLock.csproj

@@ -1,7 +1,8 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>netstandard1.3;netstandard2.1</TargetFrameworks>
+    <TargetFrameworks>netstandard1.3;netstandard2.0;netstandard2.1</TargetFrameworks>
+    <AssemblyName>NeoSmart.AsyncLock</AssemblyName>
     <RootNamespace>NeoSmart.AsyncLock</RootNamespace>
     <PackageId>NeoSmart.AsyncLock</PackageId>
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
@@ -15,7 +16,7 @@
     <PackageProjectUrl>https://neosmart.net/blog/2017/asynclock-an-asyncawait-friendly-locking-library-for-c-and-net/</PackageProjectUrl>
     <RepositoryUrl>https://github.com/neosmart/AsyncLock</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
-    <PackageTags>asynclock, async await, async, await, lock, synchronization</PackageTags>
+    <PackageTags>asynclock, async await, async, await, lock, synchronization, mutex, async mutex</PackageTags>
     <PackageReleaseNotes>
 3.2: New TryLock() and TryLockAsync() methods, CancellationToken support for synchronous locking routines.
 
@@ -43,4 +44,9 @@
     </None>
   </ItemGroup>
 
+    <ItemGroup Condition="$(TargetFramework) == 'netstandard1.3'">
+        <PackageReference Include="System.Threading.Thread" Version="4.3.0" />
+        <PackageReference Include="System.Runtime.Extensions" Version="4.3.0" />
+    </ItemGroup>
+
 </Project>