Do not react to interruptions in runBlocking before first suspension

Author: dkhalanskyjb

kotlinx-coroutines-core/jvm/src/Builders.kt

@@ -91,12 +91,11 @@ private class BlockingCoroutine<T>(
             eventLoop?.incrementUseCount()
             try {
                 while (true) {
-                    @Suppress("DEPRECATION")
-                    if (Thread.interrupted()) cancelCoroutine(InterruptedException())
                     val parkNanos = eventLoop?.processNextEvent() ?: Long.MAX_VALUE
                     // note: process next even may loose unpark flag, so check if completed before parking
                     if (isCompleted) break
                     parkNanos(this, parkNanos)
+                    if (Thread.interrupted()) cancelCoroutine(InterruptedException())
                 }
             } finally { // paranoia
                 eventLoop?.decrementUseCount()

kotlinx-coroutines-core/jvm/test/RunBlockingJvmTest.kt

@@ -65,6 +65,23 @@ class RunBlockingJvmTest : TestBase() {
         finish(5)
     }
 
+    /** Tests that [runBlocking] does not check for interruptions before the first attempt to suspend,
+     * as no blocking actually happens. */
+    @Test
+    fun testInitialPortionRunningDespiteInterruptions() {
+        Thread.currentThread().interrupt()
+        runBlocking {
+            expect(1)
+            try {
+                Thread.sleep(Long.MAX_VALUE)
+            } catch (_: InterruptedException) {
+                expect(2)
+            }
+        }
+        assertFalse(Thread.interrupted())
+        finish(3)
+    }
+
     /**
      * Tests that [runBlockingNonInterruptible] is going to run its job to completion even if it gets interrupted
      * or if thread switches occur.
@@ -138,6 +155,17 @@ class RunBlockingJvmTest : TestBase() {
         finish(3)
     }
 
+    /**
+     * Tests that starting [runBlockingNonInterruptible] in an interrupted thread does not affect the result.
+     */
+    @Test
+    fun testNonInterruptibleRunBlockingStartingInterrupted() {
+        Thread.currentThread().interrupt()
+        val v = runBlockingNonInterruptible { 42 }
+        assertEquals(42, v)
+        assertTrue(Thread.interrupted())
+    }
+
     private fun startInSeparateThreadAndInterrupt(action: (mayInterrupt: () -> Unit) -> Unit) {
         val latch = CountDownLatch(1)
         val thread = thread {