[browser][wasi] Allow uncontended synchronous waits

src/libraries/System.Private.CoreLib/src/System/Threading/Condition.cs

@@ -3,6 +3,7 @@
 
 using System.Diagnostics;
 using System.Diagnostics.Tracing;
+using System.Runtime.CompilerServices;
 
 namespace System.Threading
 {
@@ -137,6 +138,9 @@ public bool Wait(int millisecondsTimeout, object associatedObjectForMonitorWait)
             if (!_lock.IsHeldByCurrentThread)
                 throw new SynchronizationLockException();
 
+            if (millisecondsTimeout != 0)
+                RuntimeFeature.ThrowIfMultithreadingIsNotSupported();
+
             using ThreadBlockingInfo.Scope threadBlockingScope = new(this, millisecondsTimeout);
 
             Waiter waiter = GetWaiterForCurrentThread();

src/libraries/System.Private.CoreLib/src/System/Threading/ManualResetEventSlim.cs

@@ -513,8 +513,6 @@ public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken)
 
             ArgumentOutOfRangeException.ThrowIfLessThan(millisecondsTimeout, -1);
 
-            RuntimeFeature.ThrowIfMultithreadingIsNotSupported();
-
             if (!IsSet)
             {
                 if (millisecondsTimeout == 0)
@@ -523,6 +521,7 @@ public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken)
                     return false;
                 }
 
+                RuntimeFeature.ThrowIfMultithreadingIsNotSupported();
 
                 // We spin briefly before falling back to allocating and/or waiting on a true event.
                 long startTime = 0;

src/libraries/System.Private.CoreLib/src/System/Threading/Monitor.cs

@@ -140,7 +140,6 @@ private static Lock GetLockObject(object obj)
         public static bool Wait(object obj, int millisecondsTimeout)
         {
             ArgumentNullException.ThrowIfNull(obj);
-            RuntimeFeature.ThrowIfMultithreadingIsNotSupported();
 
             return GetLockObject(obj).Wait(millisecondsTimeout, obj);
         }

src/libraries/System.Private.CoreLib/src/System/Threading/SemaphoreSlim.cs

@@ -320,8 +320,6 @@ private bool WaitCore(long millisecondsTimeout, CancellationToken cancellationTo
                 return false;
             }
 
-            RuntimeFeature.ThrowIfMultithreadingIsNotSupported();
-
             long startTime = 0;
             if (millisecondsTimeout != Timeout.Infinite && millisecondsTimeout > 0)
             {
@@ -367,6 +365,8 @@ private bool WaitCore(long millisecondsTimeout, CancellationToken cancellationTo
                 // then block on (once we've released the lock).
                 if (m_asyncHead is not null)
                 {
+                    RuntimeFeature.ThrowIfMultithreadingIsNotSupported();
+
                     Debug.Assert(m_asyncTail is not null, "tail should not be null if head isn't");
                     asyncWaitTask = WaitAsyncCore(millisecondsTimeout, cancellationToken);
                 }

src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/Task.cs

@@ -3157,8 +3157,6 @@ private bool InternalWaitCore(int millisecondsTimeout, CancellationToken cancell
             }
             else
             {
-                RuntimeFeature.ThrowIfMultithreadingIsNotSupported();
-
                 returnValue = SpinThenBlockingWait(millisecondsTimeout, cancellationToken);
             }
 
@@ -3212,7 +3210,7 @@ private bool SpinThenBlockingWait(int millisecondsTimeout, CancellationToken can
             bool infiniteWait = millisecondsTimeout == Timeout.Infinite;
             uint startTimeTicks = infiniteWait ? 0 : (uint)Environment.TickCount;
             bool returnValue = SpinWait(millisecondsTimeout);
-            if (!returnValue)
+            if (!returnValue && (millisecondsTimeout != 0 || RuntimeFeature.IsMultithreadingSupported))
             {
                 RuntimeFeature.ThrowIfMultithreadingIsNotSupported();
 
@@ -5175,10 +5173,17 @@ private static bool WaitAllCore(ReadOnlySpan<Task> tasks, int millisecondsTimeou
 
             if (waitedOnTaskList != null)
             {
-                RuntimeFeature.ThrowIfMultithreadingIsNotSupported();
+                if (millisecondsTimeout != 0 || RuntimeFeature.IsMultithreadingSupported)
+                {
+                    RuntimeFeature.ThrowIfMultithreadingIsNotSupported();
 
-                // Block waiting for the tasks to complete.
-                returnValue = WaitAllBlockingCore(waitedOnTaskList, millisecondsTimeout, cancellationToken);
+                    // Block waiting for the tasks to complete.
+                    returnValue = WaitAllBlockingCore(waitedOnTaskList, millisecondsTimeout, cancellationToken);
+                }
+                else
+                {
+                    returnValue = false;
+                }
 
                 // If the wait didn't time out, ensure exceptions are propagated, and if a debugger is
                 // attached and one of these tasks requires it, that we notify the debugger of a wait completion.
@@ -5515,7 +5520,9 @@ private static int WaitAnyCore(Task[] tasks, int millisecondsTimeout, Cancellati
                 }
             }
 
-            if (signaledTaskIndex == -1 && tasks.Length != 0)
+            if (signaledTaskIndex == -1 &&
+                tasks.Length != 0 &&
+                (millisecondsTimeout != 0 || RuntimeFeature.IsMultithreadingSupported))
             {
                 RuntimeFeature.ThrowIfMultithreadingIsNotSupported();
 

src/libraries/System.Runtime/tests/System.Threading.Tasks.Tests/Task/TaskRtTests_Core.cs

@@ -2430,6 +2430,22 @@ public static void RunTaskWaitTest()
             }
         }
 
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotMultithreadingSupported))]
+        public static void Wait_SingleThreaded()
+        {
+            Task incompleteTask = new TaskCompletionSource().Task;
+
+            Task.CompletedTask.Wait();
+            Assert.True(Task.CompletedTask.Wait(0));
+            Assert.False(incompleteTask.Wait(0));
+            Assert.False(Task.WaitAll([incompleteTask], 0));
+            Assert.Equal(-1, Task.WaitAny([incompleteTask], 0));
+
+            Assert.Throws<PlatformNotSupportedException>(() => incompleteTask.Wait(1));
+            Assert.Throws<PlatformNotSupportedException>(() => Task.WaitAll([incompleteTask], 1));
+            Assert.Throws<PlatformNotSupportedException>(() => Task.WaitAny([incompleteTask], 1));
+        }
+
         // Just runs a task and waits on it.
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsMultithreadingSupported))]
         public static void RunTaskWaitTest_NegativeTests()

src/libraries/System.Threading/tests/ManualResetEventSlimTests.cs

@@ -68,6 +68,21 @@ public static void RunManualResetEventSlimTest2_TimeoutWait()
             }
         }
 
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotMultithreadingSupported))]
+        public static void Wait_SingleThreaded()
+        {
+            using ManualResetEventSlim setEvent = new(true);
+            setEvent.Wait();
+            Assert.True(setEvent.Wait(1));
+            Assert.True(setEvent.Wait(TimeSpan.Zero));
+
+            using ManualResetEventSlim unsetEvent = new(false);
+            Assert.False(unsetEvent.Wait(0));
+            Assert.False(unsetEvent.Wait(TimeSpan.Zero));
+            Assert.Throws<PlatformNotSupportedException>(() => unsetEvent.Wait(1));
+            Assert.Throws<PlatformNotSupportedException>(() => unsetEvent.Wait());
+        }
+
         // Tests timeout on an event that is never set.
         [Fact]
         public static void RunManualResetEventSlimTest3_ConstructorTests()

src/libraries/System.Threading/tests/MonitorTests.cs

@@ -413,6 +413,19 @@ public static void Wait_Invalid()
                 () => Monitor.Wait(obj, TimeSpan.FromMilliseconds((double)int.MaxValue + 1)));
         }
 
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotMultithreadingSupported))]
+        public static void Wait_SingleThreaded()
+        {
+            object obj = new();
+            lock (obj)
+            {
+                Assert.False(Monitor.Wait(obj, 0));
+                Assert.False(Monitor.Wait(obj, TimeSpan.Zero));
+                Assert.Throws<PlatformNotSupportedException>(() => Monitor.Wait(obj, 1));
+                Assert.Throws<PlatformNotSupportedException>(() => Monitor.Wait(obj));
+            }
+        }
+
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsMultithreadingSupported))]
         public static void WaitTest()
         {

src/libraries/System.Threading/tests/SemaphoreSlimTests.cs

@@ -63,6 +63,26 @@ public static void RunSemaphoreSlimTest1_Wait()
             RunSemaphoreSlimTest1_Wait_Helper(1, 10, TimeSpan.FromMilliseconds(uint.MaxValue), true, null);
         }
 
+        [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotMultithreadingSupported))]
+        public static void Wait_SingleThreaded()
+        {
+            using SemaphoreSlim semaphore = new(1, 1);
+
+            semaphore.Wait();
+            semaphore.Release();
+            semaphore.Wait(CancellationToken.None);
+            semaphore.Release();
+            Assert.True(semaphore.Wait(1));
+            semaphore.Release();
+            Assert.True(semaphore.Wait(TimeSpan.FromMilliseconds(1)));
+            semaphore.Release();
+            Assert.True(semaphore.Wait(0, CancellationToken.None));
+
+            Assert.False(semaphore.Wait(0));
+            Assert.Throws<PlatformNotSupportedException>(() => semaphore.Wait(1));
+            Assert.Throws<PlatformNotSupportedException>(() => semaphore.Wait());
+        }
+
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsMultithreadingSupported))]
         public static void RunSemaphoreSlimTest1_Wait_NegativeCases()
         {

src/mono/System.Private.CoreLib/src/System/Threading/Monitor.Mono.cs

@@ -77,7 +77,6 @@ public static bool IsEntered(object obj)
         public static bool Wait(object obj, int millisecondsTimeout)
         {
             ArgumentNullException.ThrowIfNull(obj);
-            RuntimeFeature.ThrowIfMultithreadingIsNotSupported();
 
             return ObjWait(millisecondsTimeout, obj);
         }
@@ -126,6 +125,9 @@ private static bool ObjWait(int millisecondsTimeout, object obj)
             if (!ObjectHeader.HasOwner(obj))
                 throw new SynchronizationLockException();
 
+            if (millisecondsTimeout != 0)
+                RuntimeFeature.ThrowIfMultithreadingIsNotSupported();
+
             bool sendWaitEvents =
                 millisecondsTimeout != 0 &&
                 NativeRuntimeEventSource.Log.IsEnabled(EventLevel.Verbose, NativeRuntimeEventSource.Keywords.WaitHandleKeyword);

src/mono/wasm/threads.md

@@ -39,6 +39,12 @@ JIT/interpreter/AOT to drop the multi-threaded implementation in the single-thre
 
 The implementation should not use `[UnsupportedOSPlatform("browser")]`
 
+Synchronous wait APIs that are unsupported without multithreading should call
+`ThrowIfMultithreadingIsNotSupported()` only when they would actually block. They can succeed when
+a semaphore count, task completion, or set state is already available, and a zero-timeout wait
+should return its normal result. The public APIs remain annotated as unsupported because whether a
+wait blocks depends on runtime state.
+
 ## Native runtime preprocessor defines ##
 
 In `src/mono/mono` and `src/mono/wasm` `DISABLE_THREADS` is defined for single-threaded builds (same