Added support of synchronous lock on WASM

Author: sakno

src/DotNext.Threading/Threading/AsyncAutoResetEvent.cs

@@ -22,7 +22,7 @@ internal StateManager(bool initialState)
 
         readonly bool ILockManager.IsLockAllowed => Value;
 
-        void ILockManager.AcquireLock(bool synchronously) => Value = false;
+        void ILockManager.AcquireLock() => Value = false;
     }
 
     private ValueTaskPool<bool, DefaultWaitNode, Action<DefaultWaitNode>> pool;
@@ -78,7 +78,7 @@ public bool Reset()
         ObjectDisposedException.ThrowIf(IsDisposed, this);
 
         Monitor.Enter(SyncRoot);
-        var result = TryAcquire(ref manager, synchronously: true);
+        var result = TryAcquire(ref manager);
         Monitor.Exit(SyncRoot);
 
         return result;
@@ -96,25 +96,28 @@ public bool Set()
         var suspendedCaller = default(ManualResetCompletionSource);
         bool result;
 
-        lock (SyncRoot)
+        if (result = !manager.Value)
         {
-            if (result = !manager.Value)
+            lock (SyncRoot)
             {
-                for (LinkedValueTaskCompletionSource<bool>? current = WaitQueueHead, next; ; current = next)
+                if (result = !manager.Value)
                 {
-                    if (current is null)
-                    {
-                        manager.Value = true;
-                        break;
-                    }
-
-                    next = current.Next;
-
-                    // skip dead node
-                    if (RemoveAndSignal(current, out var resumable))
+                    for (LinkedValueTaskCompletionSource<bool>? current = WaitQueueHead, next;; current = next)
                     {
-                        suspendedCaller = resumable ? current : null;
-                        break;
+                        if (current is null)
+                        {
+                            manager.Value = true;
+                            break;
+                        }
+
+                        next = current.Next;
+
+                        // skip dead node
+                        if (RemoveAndSignal(current, out var resumable))
+                        {
+                            suspendedCaller = resumable ? current : null;
+                            break;
+                        }
                     }
                 }
             }

src/DotNext.Threading/Threading/AsyncCountdownEvent.cs

@@ -33,7 +33,7 @@ internal void IncrementInitial(long value)
         internal bool Decrement(long value = 1L)
             => (Current = Math.Max(0L, Current - value)) is 0L;
 
-        readonly void ILockManager.AcquireLock(bool synchronously)
+        readonly void ILockManager.AcquireLock()
         {
             // nothing to do here
         }

src/DotNext.Threading/Threading/AsyncCounter.cs

@@ -21,7 +21,7 @@ public class AsyncCounter : QueuedSynchronizer, IAsyncEvent
     [StructLayout(LayoutKind.Auto)]
     private struct StateManager : ILockManager<DefaultWaitNode>
     {
-        required internal long Value;
+        internal required long Value;
 
         internal void Increment(long delta) => Value = checked(Value + delta);
 
@@ -36,7 +36,7 @@ internal bool TryReset()
 
         readonly bool ILockManager.IsLockAllowed => Value > 0L;
 
-        void ILockManager.AcquireLock(bool synchronously) => Decrement();
+        void ILockManager.AcquireLock() => Decrement();
     }
 
     private ValueTaskPool<bool, DefaultWaitNode, Action<DefaultWaitNode>> pool;
@@ -203,7 +203,7 @@ public bool TryDecrement()
         ObjectDisposedException.ThrowIf(IsDisposed, this);
 
         Monitor.Enter(SyncRoot);
-        var result = TryAcquire(ref manager, synchronously: true);
+        var result = TryAcquire(ref manager);
         Monitor.Exit(SyncRoot);
 
         return result;

src/DotNext.Threading/Threading/AsyncEventHub.cs

@@ -562,7 +562,7 @@ internal WaitAllManager(AsyncEventHub stateHolder, in UInt128 mask)
 
         bool ILockManager.IsLockAllowed => (state.Value & mask) == mask;
 
-        void ILockManager.AcquireLock(bool synchronously)
+        void ILockManager.AcquireLock()
         {
             // no need to reset events
         }
@@ -595,7 +595,7 @@ internal ICollection<int>? Events
 
         bool ILockManager.IsLockAllowed => (state.Value & mask) != UInt128.Zero;
 
-        void ILockManager.AcquireLock(bool synchronously)
+        void ILockManager.AcquireLock()
         {
             if (Events is { } collection)
                 FillIndices(state.Value & mask, collection);

src/DotNext.Threading/Threading/AsyncExclusiveLock.cs

@@ -1,6 +1,5 @@
 using System.Diagnostics;
 using System.Runtime.InteropServices;
-using System.Runtime.Versioning;
 
 namespace DotNext.Threading;
 
@@ -17,25 +16,23 @@ public class AsyncExclusiveLock : QueuedSynchronizer, IAsyncDisposable
     private struct LockManager : ILockManager<DefaultWaitNode>
     {
         // null - not acquired, Sentinel.Instance - acquired asynchronously, Thread - acquired synchronously
-        private object? state;
+        private bool state;
 
-        internal readonly bool Value => state is not null;
+        internal readonly bool Value => state;
 
-        internal readonly bool VolatileRead() => Volatile.Read(in state) is not null;
+        internal readonly bool VolatileRead() => Volatile.Read(in state);
 
-        public readonly bool IsLockAllowed => state is null;
+        public readonly bool IsLockAllowed => state is false;
 
-        public void AcquireLock(bool synchronously)
-            => state = synchronously ? Thread.CurrentThread : Sentinel.Instance;
+        public void AcquireLock()
+            => state = true;
 
-        internal void ExitLock() => state = null;
-
-        readonly bool ILockManager.IsLockHeldByCurrentThread
-            => ReferenceEquals(state, Thread.CurrentThread);
+        internal void ExitLock() => state = false;
     }
 
     private ValueTaskPool<bool, DefaultWaitNode, Action<DefaultWaitNode>> pool;
     private LockManager manager;
+    private Thread? lockOwner;
 
     /// <summary>
     /// Initializes a new asynchronous exclusive lock.
@@ -88,10 +85,20 @@ public bool TryAcquire()
         return TryAcquireCore();
     }
 
+    private bool IsLockHelpByCurrentThread
+    {
+        get => lockOwner is not { } owner || ReferenceEquals(owner, Thread.CurrentThread);
+        set
+        {
+            if (value)
+                lockOwner = Thread.CurrentThread;
+        }
+    }
+
     private bool TryAcquireCore()
     {
         Monitor.Enter(SyncRoot);
-        var result = TryAcquire(ref manager, synchronously: true);
+        var result = IsLockHelpByCurrentThread = TryAcquire(ref manager);
         Monitor.Exit(SyncRoot);
 
         return result;
@@ -106,16 +113,22 @@ private bool TryAcquireCore()
     /// <exception cref="ArgumentOutOfRangeException"><paramref name="timeout"/> is negative.</exception>
     /// <exception cref="ObjectDisposedException">This object has been disposed.</exception>
     /// <exception cref="LockRecursionException">The lock is already acquired by the current thread.</exception>
-    [UnsupportedOSPlatform("browser")]
     public bool TryAcquire(TimeSpan timeout, CancellationToken token = default)
     {
-        ObjectDisposedException.ThrowIf(IsDisposed, this);
+        if (IsLockHelpByCurrentThread)
+            throw new LockRecursionException();
+        
+        bool result;
+        try
+        {
+            IsLockHelpByCurrentThread = result = TryAcquireAsync(timeout, token).Wait();
+        }
+        catch (OperationCanceledException e) when (e.CancellationToken == token)
+        {
+            result = false;
+        }
 
-        return timeout == TimeSpan.Zero
-            ? TryAcquireCore()
-            : token.CanBeCanceled
-                ? TryAcquire(new Timeout(timeout), ref manager, token)
-                : TryAcquire(new Timeout(timeout), ref manager);
+        return result;
     }
 
     /// <summary>
@@ -228,7 +241,7 @@ public ValueTask StealAsync(object? reason = null, CancellationToken token = def
             // skip dead node
             if (RemoveAndSignal(current, out var resumable))
             {
-                manager.AcquireLock(synchronously: false);
+                manager.AcquireLock();
                 return resumable ? current : null;
             }
         }
@@ -252,16 +265,12 @@ public void Release()
                 throw new SynchronizationLockException(ExceptionMessages.NotInLock);
 
             manager.ExitLock();
+            lockOwner = null;
             suspendedCaller = DrainWaitQueue();
 
             if (IsDisposing && IsReadyToDispose)
             {
                 Dispose(true);
-                Monitor.PulseAll(SyncRoot);
-            }
-            else
-            {
-                Monitor.Pulse(SyncRoot);
             }
         }
 

src/DotNext.Threading/Threading/AsyncManualResetEvent.cs

@@ -30,7 +30,7 @@ internal bool TryReset()
 
         readonly bool ILockManager.IsLockAllowed => Value;
 
-        readonly void ILockManager.AcquireLock(bool synchronously)
+        readonly void ILockManager.AcquireLock()
         {
             // nothing to do here
         }