Fix forever lock of main thread in runBlocking

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

@@ -8,7 +8,6 @@
 
 package kotlinx.coroutines
 
-import java.util.concurrent.locks.*
 import kotlin.contracts.*
 import kotlin.coroutines.*
 
@@ -69,22 +68,34 @@ private class BlockingCoroutine<T>(
     override fun afterCompletion(state: Any?) {
         // wake up blocked thread
         if (Thread.currentThread() != blockedThread)
-            LockSupport.unpark(blockedThread)
+            unpark(blockedThread)
     }
 
     @Suppress("UNCHECKED_CAST")
     fun joinBlocking(): T {
         registerTimeLoopThread()
         try {
             eventLoop?.incrementUseCount()
+            val isMainThread = Thread.currentThread().id == 1L
             try {
                 while (true) {
                     @Suppress("DEPRECATION")
                     if (Thread.interrupted()) throw InterruptedException().also { cancelCoroutine(it) }
                     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 (parkNanos <= 0 || parkNanos >= Long.MAX_VALUE) {
+                        0L
+                    } else {
+                        if (parkNanos > 10_000_000L && isMainThread) {
+                            // Restrict long park MainThread. No more than 10ms. delay 1ms
+                            1_000_000L
+                        } else {
+                            parkNanos
+                        }
+                    }.let {
+                        parkNanos(this, it)
+                    }
                 }
             } finally { // paranoia
                 eventLoop?.decrementUseCount()

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

@@ -60,10 +60,13 @@ internal inline fun unregisterTimeLoopThread() {
 
 @InlineOnly
 internal inline fun parkNanos(blocker: Any, nanos: Long) {
-    timeSource?.parkNanos(blocker, nanos) ?: LockSupport.parkNanos(blocker, nanos)
+    if (0L <= nanos && nanos < Long.MAX_VALUE) {
+        timeSource?.parkNanos(blocker, nanos) ?: LockSupport.parkNanos(blocker, nanos)
+    }
 }
 
 @InlineOnly
 internal inline fun unpark(thread: Thread) {
-    timeSource?.unpark(thread) ?: LockSupport.unpark(thread)
+    timeSource?.unpark(thread)
+    LockSupport.unpark(thread)
 }