Implement Thread.Interrupt on NativeAOT on Windows

src/coreclr/nativeaot/Runtime/thread.cpp

@@ -1160,6 +1160,23 @@ bool Thread::CheckPendingRedirect(PCODE eip)
 
 #endif // TARGET_X86
 
+void Thread::SetInterrupted(bool isInterrupted)
+{
+    if (isInterrupted)
+    {
+        SetState(TSF_Interrupted);
+    }
+    else
+    {
+        ClearState(TSF_Interrupted);
+    }
+}
+
+bool Thread::CheckInterrupted()
+{
+    return IsStateSet(TSF_Interrupted);
+}
+
 #endif // !DACCESS_COMPILE
 
 void Thread::ValidateExInfoStack()
@@ -1323,6 +1340,39 @@ FCIMPL0(size_t, RhGetDefaultStackSize)
 }
 FCIMPLEND
 
+#ifdef TARGET_WINDOWS
+// Native APC callback for Thread.Interrupt
+// This callback sets the interrupt flag on the current thread
+static VOID CALLBACK InterruptApcCallback(ULONG_PTR /* parameter */)
+{
+    // Set the interrupt flag on the current thread
+    Thread* pCurrentThread = ThreadStore::RawGetCurrentThread();
+    if (pCurrentThread != nullptr)
+    {
+        pCurrentThread->SetInterrupted(true);
+    }
+}
+
+// Function to get the address of the interrupt APC callback
+FCIMPL0(void*, RhGetInterruptApcCallback)
+{
+    return (void*)InterruptApcCallback;
+}
+FCIMPLEND
+
+FCIMPL0(FC_BOOL_RET, RhCheckAndClearPendingInterrupt)
+{
+    Thread* pCurrentThread = ThreadStore::RawGetCurrentThread();
+    if (pCurrentThread != nullptr && pCurrentThread->CheckInterrupted())
+    {
+        pCurrentThread->SetInterrupted(false);
+        FC_RETURN_BOOL(true);
+    }
+    FC_RETURN_BOOL(false);
+}
+FCIMPLEND
+#endif // TARGET_WINDOWS
+
 // Standard calling convention variant and actual implementation for RhpReversePInvokeAttachOrTrapThread
 EXTERN_C NOINLINE void FASTCALL RhpReversePInvokeAttachOrTrapThread2(ReversePInvokeFrame* pFrame)
 {

src/coreclr/nativeaot/Runtime/thread.h

@@ -132,7 +132,7 @@ struct ee_alloc_context
 
 struct RuntimeThreadLocals
 {
-    ee_alloc_context        m_eeAllocContext;               
+    ee_alloc_context        m_eeAllocContext;
     uint32_t volatile       m_ThreadStateFlags;                     // see Thread::ThreadStateFlags enum
     PInvokeTransitionFrame* m_pTransitionFrame;
     PInvokeTransitionFrame* m_pDeferredTransitionFrame;             // see Thread::EnablePreemptiveMode
@@ -214,6 +214,7 @@ class Thread : private RuntimeThreadLocals
                                                     //
                                                     // On Unix this is an optimization to not queue up more signals when one is
                                                     // still being processed.
+        TSF_Interrupted         = 0x00000200,       // Set to indicate Thread.Interrupt() has been called on this thread
     };
 private:
 
@@ -390,6 +391,9 @@ class Thread : private RuntimeThreadLocals
     void                SetPendingRedirect(PCODE eip);
     bool                CheckPendingRedirect(PCODE eip);
 #endif
+
+    void                SetInterrupted(bool isInterrupted);
+    bool                CheckInterrupted();
 };
 
 #ifndef __GCENV_BASE_INCLUDED__

src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/RuntimeImports.cs

@@ -607,6 +607,14 @@ internal static IntPtr RhGetModuleSection(TypeManagerHandle module, ReadyToRunSe
         [RuntimeImport(RuntimeLibrary, "RhGetDefaultStackSize")]
         internal static extern unsafe IntPtr RhGetDefaultStackSize();
 
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        [RuntimeImport(RuntimeLibrary, "RhGetInterruptApcCallback")]
+        internal static extern unsafe delegate* unmanaged<nuint, void> RhGetInterruptApcCallback();
+
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        [RuntimeImport(RuntimeLibrary, "RhCheckAndClearPendingInterrupt")]
+        internal static extern bool RhCheckAndClearPendingInterrupt();
+
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         [RuntimeImport("*", "RhGetCurrentThunkContext")]
         internal static extern IntPtr GetCurrentInteropThunkContext();

src/coreclr/nativeaot/System.Private.CoreLib/src/System/Threading/Thread.NativeAot.Windows.cs

@@ -26,6 +26,70 @@ public sealed partial class Thread
 
         partial void PlatformSpecificInitialize();
 
+        internal static void SleepInternal(int millisecondsTimeout)
+        {
+            Debug.Assert(millisecondsTimeout >= -1);
+
+            Thread currentThread = CurrentThread;
+            if (millisecondsTimeout == 0)
+            {
+                Thread.CheckForPendingInterrupt();
+                UninterruptibleSleep0();
+                return;
+            }
+
+            if (millisecondsTimeout == -1)
+            {
+                // Infinite wait - use alertable wait
+                currentThread.SetWaitSleepJoinState();
+                try
+                {
+                    uint result;
+                    do
+                    {
+                        Thread.CheckForPendingInterrupt();
+                        result = Interop.Kernel32.SleepEx(uint.MaxValue, true);
+                        if (result == Interop.Kernel32.WAIT_IO_COMPLETION)
+                        {
+                            // Check if this was our interrupt APC
+                            Thread.CheckForPendingInterrupt();
+                        }
+                    } while (result == Interop.Kernel32.WAIT_IO_COMPLETION);
+                }
+                finally
+                {
+                    currentThread.ClearWaitSleepJoinState();
+                }
+            }
+            else
+            {
+                // Timed wait - use alertable wait
+                currentThread.SetWaitSleepJoinState();
+                uint startTicks = (uint)Environment.TickCount;
+                uint remainingTimeout = (uint)millisecondsTimeout;
+                try
+                {
+                    uint result;
+                    do
+                    {
+                        Thread.CheckForPendingInterrupt();
+                        result = Interop.Kernel32.SleepEx(remainingTimeout, true);
+                        if (result == Interop.Kernel32.WAIT_IO_COMPLETION)
+                        {
+                            // Check if this was our interrupt APC
+                            Thread.CheckForPendingInterrupt();
+                            uint elapsed = (uint)Environment.TickCount - startTicks;
+                            remainingTimeout = elapsed >= (uint)millisecondsTimeout ? 0 : (uint)millisecondsTimeout - elapsed;
+                        }
+                    } while (result == Interop.Kernel32.WAIT_IO_COMPLETION && remainingTimeout > 0);
+                }
+                finally
+                {
+                    currentThread.ClearWaitSleepJoinState();
+                }
+            }
+        }
+
         // Platform-specific initialization of foreign threads, i.e. threads not created by Thread.Start
         private void PlatformSpecificInitializeExistingThread()
         {
@@ -154,18 +218,56 @@ private bool JoinInternal(int millisecondsTimeout)
 
             try
             {
-                int result;
-
                 if (millisecondsTimeout == 0)
                 {
-                    result = (int)Interop.Kernel32.WaitForSingleObject(waitHandle.DangerousGetHandle(), 0);
+                    int result = (int)Interop.Kernel32.WaitForSingleObject(waitHandle.DangerousGetHandle(), 0);
+                    return result == (int)Interop.Kernel32.WAIT_OBJECT_0;
                 }
                 else
                 {
-                    result = WaitHandle.WaitOneCore(waitHandle.DangerousGetHandle(), millisecondsTimeout, useTrivialWaits: false);
+                    Thread currentThread = CurrentThread;
+                    currentThread.SetWaitSleepJoinState();
+                    try
+                    {
+                        uint result;
+                        if (millisecondsTimeout == -1)
+                        {
+                            // Infinite wait
+                            do
+                            {
+                                Thread.CheckForPendingInterrupt();
+                                result = Interop.Kernel32.WaitForSingleObjectEx(waitHandle.DangerousGetHandle(), uint.MaxValue, Interop.BOOL.TRUE);
+                                if (result == Interop.Kernel32.WAIT_IO_COMPLETION)
+                                {
+                                    // Check if this was our interrupt APC
+                                    Thread.CheckForPendingInterrupt();
+                                }
+                            } while (result == Interop.Kernel32.WAIT_IO_COMPLETION);
+                        }
+                        else
+                        {
+                            uint startTicks = (uint)Environment.TickCount;
+                            uint remainingTimeout = (uint)millisecondsTimeout;
+                            do
+                            {
+                                Thread.CheckForPendingInterrupt();
+                                result = Interop.Kernel32.WaitForSingleObjectEx(waitHandle.DangerousGetHandle(), remainingTimeout, Interop.BOOL.TRUE);
+                                if (result == Interop.Kernel32.WAIT_IO_COMPLETION)
+                                {
+                                    // Check if this was our interrupt APC
+                                    Thread.CheckForPendingInterrupt();
+                                    uint elapsed = (uint)Environment.TickCount - startTicks;
+                                    remainingTimeout = elapsed >= (uint)millisecondsTimeout ? 0 : (uint)millisecondsTimeout - elapsed;
+                                }
+                            } while (result == Interop.Kernel32.WAIT_IO_COMPLETION && remainingTimeout > 0);
+                        }
+                        return result == (int)Interop.Kernel32.WAIT_OBJECT_0;
+                    }
+                    finally
+                    {
+                        currentThread.ClearWaitSleepJoinState();
+                    }
                 }
-
-                return result == (int)Interop.Kernel32.WAIT_OBJECT_0;
             }
             finally
             {
@@ -212,6 +314,13 @@ private unsafe bool CreateThread(GCHandle<Thread> thisThreadHandle)
             // CoreCLR ignores OS errors while setting the priority, so do we
             SetPriorityLive(_priority);
 
+            // If the thread was interrupted before it was started, queue the interruption now
+            if (GetThreadStateBit(Interrupted))
+            {
+                ClearThreadStateBit(Interrupted);
+                Interrupt();
+            }
+
             Interop.Kernel32.ResumeThread(_osHandle);
             return true;
         }
@@ -393,7 +502,41 @@ internal static Thread EnsureThreadPoolThreadInitialized()
             return InitializeExistingThreadPoolThread();
         }
 
-        public void Interrupt() { throw new PlatformNotSupportedException(); }
+        public void Interrupt()
+        {
+            using (_lock.EnterScope())
+            {
+                // Thread.Interrupt for dead thread should do nothing
+                if (IsDead())
+                {
+                    return;
+                }
+
+                // Thread.Interrupt for thread that has not been started yet should queue a pending interrupt
+                if (GetThreadStateBit(ThreadState.Unstarted))
+                {
+                    SetThreadStateBit(Interrupted);
+                    return;
+                }
+
+                // Queue APC to interrupt the target thread
+                if (!_osHandle.IsInvalid)
+                {
+                    unsafe
+                    {
+                        Interop.Kernel32.QueueUserAPC(RuntimeImports.RhGetInterruptApcCallback(), _osHandle, 0);
+                    }
+                }
+            }
+        }
+
+        internal static void CheckForPendingInterrupt()
+        {
+            if (RuntimeImports.RhCheckAndClearPendingInterrupt())
+            {
+                throw new ThreadInterruptedException();
+            }
+        }
 
         internal static bool ReentrantWaitsEnabled =>
             GetCurrentApartmentType() == ApartmentType.STA;

src/coreclr/nativeaot/System.Private.CoreLib/src/System/Threading/Thread.NativeAot.cs

@@ -17,6 +17,7 @@ public sealed partial class Thread
     {
         // Extra bits used in _threadState
         private const ThreadState ThreadPoolThread = (ThreadState)0x1000;
+        private const ThreadState Interrupted = (ThreadState)0x2000;
 
         // Bits of _threadState that are returned by the ThreadState property
         private const ThreadState PublicThreadStateMask = (ThreadState)0x1FF;

src/libraries/Common/src/Interop/Windows/Kernel32/Interop.Threading.cs

@@ -78,5 +78,12 @@ internal enum ThreadPriority : int
         [LibraryImport(Libraries.Kernel32, SetLastError = true)]
         [return: MarshalAs(UnmanagedType.Bool)]
         internal static partial bool GetThreadIOPendingFlag(nint hThread, out BOOL lpIOIsPending);
+
+        [LibraryImport(Libraries.Kernel32, SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static unsafe partial bool QueueUserAPC(delegate* unmanaged<nuint, void> pfnAPC, SafeHandle hThread, nuint dwData);
+
+        [LibraryImport(Libraries.Kernel32)]
+        internal static partial uint SleepEx(uint dwMilliseconds, [MarshalAs(UnmanagedType.Bool)] bool bAlertable);
     }
 }

src/libraries/System.Private.CoreLib/src/System/Threading/Thread.Windows.cs

@@ -18,7 +18,7 @@ public sealed partial class Thread
     {
         internal static void UninterruptibleSleep0() => Interop.Kernel32.Sleep(0);
 
-#if !CORECLR
+#if MONO
         private static void SleepInternal(int millisecondsTimeout)
         {
             Debug.Assert(millisecondsTimeout >= -1);

src/libraries/System.Private.CoreLib/src/System/Threading/WaitHandle.Windows.cs

@@ -75,6 +75,11 @@ private static unsafe int WaitForMultipleObjectsIgnoringSyncContext(IntPtr* pHan
                 if (result != Interop.Kernel32.WAIT_IO_COMPLETION)
                     break;
 
+#if !MONO
+                // Check for thread interrupt when APC completion occurs
+                Thread.CheckForPendingInterrupt();
+#endif
+
                 // Handle APC completion by adjusting timeout and retrying
                 if (millisecondsTimeout != -1)
                 {
@@ -140,6 +145,11 @@ private static int SignalAndWaitCore(IntPtr handleToSignal, IntPtr handleToWaitO
             // Handle APC completion by retrying with WaitForSingleObjectEx (without signaling again)
             while (ret == Interop.Kernel32.WAIT_IO_COMPLETION)
             {
+#if !MONO
+                // Check for thread interrupt when APC completion occurs
+                Thread.CheckForPendingInterrupt();
+#endif
+
                 if (millisecondsTimeout != -1)
                 {
                     long currentTime = Environment.TickCount64;

src/libraries/System.Threading.Thread/tests/ThreadTests.cs

@@ -749,7 +749,7 @@ public static void AbortSuspendTest()
             verify();
 
             e.Set();
-            waitForThread(); 
+            waitForThread();
         }
 
         private static void VerifyLocalDataSlot(LocalDataStoreSlot slot)
@@ -916,7 +916,6 @@ public static void LocalDataSlotTest()
 
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/49521", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/69919", typeof(PlatformDetection), nameof(PlatformDetection.IsNativeAot))]
         public static void InterruptTest()
         {
             // Interrupting a thread that is not blocked does not do anything, but once the thread starts blocking, it gets
@@ -966,7 +965,6 @@ public static void InterruptTest()
         }
 
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
-        [ActiveIssue("https://github.com/dotnet/runtime/issues/69919", typeof(PlatformDetection), nameof(PlatformDetection.IsNativeAot))]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/49521", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
         public static void InterruptInFinallyBlockTest_SkipOnDesktopFramework()
         {

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

@@ -491,7 +491,6 @@ public static void ObjectHeaderSyncBlockTransitionTryEnterRaceTest()
         [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/49521", TestPlatforms.Windows, TargetFrameworkMonikers.Netcoreapp, TestRuntimes.Mono)]
         [ActiveIssue("https://github.com/dotnet/runtime/issues/87718", TestRuntimes.Mono)]
-        [ActiveIssue("https://github.com/dotnet/runtimelab/issues/155", typeof(PlatformDetection), nameof(PlatformDetection.IsNativeAot))]
         public static void InterruptWaitTest()
         {
             object obj = new();

src/tests/baseservices/threading/regressions/115178/115178.cs

@@ -288,12 +288,7 @@ public static int TestEntryPoint()
     {
         RunTestUsingInfiniteWait();
         RunTestUsingTimedWait();
-
-        // Thread.Interrupt is not implemented on NativeAOT - https://github.com/dotnet/runtime/issues/69919
-        if (!TestLibrary.Utilities.IsNativeAot)
-        {
-            RunTestInterruptInfiniteWait();
-        }
+        RunTestInterruptInfiniteWait();
 
         return result;
     }