Enable lazier initialization of Dispatchers.IO

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

@@ -62,7 +62,7 @@ public actual object Dispatchers {
      * during operations over IO dispatcher.
      */
     @JvmStatic
-    public val IO: CoroutineDispatcher = DefaultIoScheduler
+    public val IO: CoroutineDispatcher get() = DefaultIoScheduler
 
     /**
      * Shuts down built-in dispatchers, such as [Default] and [IO],

kotlinx-coroutines-core/jvm/src/scheduling/Dispatcher.kt

@@ -32,68 +32,6 @@ internal object DefaultScheduler : SchedulerCoroutineDispatcher(
     override fun toString(): String = "Dispatchers.Default"
 }
 
-// The unlimited instance of Dispatchers.IO that utilizes all the threads CoroutineScheduler provides
-private object UnlimitedIoScheduler : CoroutineDispatcher() {
-
-    @InternalCoroutinesApi
-    override fun dispatchYield(context: CoroutineContext, block: Runnable) {
-        DefaultScheduler.dispatchWithContext(block, BlockingContext, true)
-    }
-
-    override fun dispatch(context: CoroutineContext, block: Runnable) {
-        DefaultScheduler.dispatchWithContext(block, BlockingContext, false)
-    }
-
-    override fun limitedParallelism(parallelism: Int, name: String?): CoroutineDispatcher {
-        parallelism.checkParallelism()
-        if (parallelism >= MAX_POOL_SIZE) {
-            return namedOrThis(name)
-        }
-        return super.limitedParallelism(parallelism, name)
-    }
-
-    // This name only leaks to user code as part of .limitedParallelism machinery
-    override fun toString(): String {
-        return "Dispatchers.IO"
-    }
-}
-
-// Dispatchers.IO
-internal object DefaultIoScheduler : ExecutorCoroutineDispatcher(), Executor {
-
-    private val default = UnlimitedIoScheduler.limitedParallelism(
-        systemProp(
-            IO_PARALLELISM_PROPERTY_NAME,
-            64.coerceAtLeast(AVAILABLE_PROCESSORS)
-        )
-    )
-
-    override val executor: Executor
-        get() = this
-
-    override fun execute(command: java.lang.Runnable) = dispatch(EmptyCoroutineContext, command)
-
-    override fun limitedParallelism(parallelism: Int, name: String?): CoroutineDispatcher {
-        // See documentation to Dispatchers.IO for the rationale
-        return UnlimitedIoScheduler.limitedParallelism(parallelism, name)
-    }
-
-    override fun dispatch(context: CoroutineContext, block: Runnable) {
-        default.dispatch(context, block)
-    }
-
-    @InternalCoroutinesApi
-    override fun dispatchYield(context: CoroutineContext, block: Runnable) {
-        default.dispatchYield(context, block)
-    }
-
-    override fun close() {
-        error("Cannot be invoked on Dispatchers.IO")
-    }
-
-    override fun toString(): String = "Dispatchers.IO"
-}
-
 // Instantiated in tests so we can test it in isolation
 internal open class SchedulerCoroutineDispatcher(
     private val corePoolSize: Int = CORE_POOL_SIZE,

kotlinx-coroutines-core/jvm/src/scheduling/IoDispatcher.kt

@@ -0,0 +1,68 @@
+package kotlinx.coroutines.scheduling
+
+import kotlinx.coroutines.*
+import kotlinx.coroutines.internal.*
+import java.util.concurrent.*
+import kotlin.coroutines.*
+
+// The unlimited instance of Dispatchers.IO that utilizes all the threads CoroutineScheduler provides
+private object UnlimitedIoScheduler : CoroutineDispatcher() {
+
+    @InternalCoroutinesApi
+    override fun dispatchYield(context: CoroutineContext, block: Runnable) {
+        DefaultScheduler.dispatchWithContext(block, BlockingContext, true)
+    }
+
+    override fun dispatch(context: CoroutineContext, block: Runnable) {
+        DefaultScheduler.dispatchWithContext(block, BlockingContext, false)
+    }
+
+    override fun limitedParallelism(parallelism: Int, name: String?): CoroutineDispatcher {
+        parallelism.checkParallelism()
+        if (parallelism >= MAX_POOL_SIZE) {
+            return namedOrThis(name)
+        }
+        return super.limitedParallelism(parallelism, name)
+    }
+
+    // This name only leaks to user code as part of .limitedParallelism machinery
+    override fun toString(): String {
+        return "Dispatchers.IO"
+    }
+}
+
+// Dispatchers.IO
+internal object DefaultIoScheduler : ExecutorCoroutineDispatcher(), Executor {
+
+    private val default = UnlimitedIoScheduler.limitedParallelism(
+        systemProp(
+            IO_PARALLELISM_PROPERTY_NAME,
+            64.coerceAtLeast(AVAILABLE_PROCESSORS)
+        )
+    )
+
+    override val executor: Executor
+        get() = this
+
+    override fun execute(command: java.lang.Runnable) = dispatch(EmptyCoroutineContext, command)
+
+    override fun limitedParallelism(parallelism: Int, name: String?): CoroutineDispatcher {
+        // See documentation to Dispatchers.IO for the rationale
+        return UnlimitedIoScheduler.limitedParallelism(parallelism, name)
+    }
+
+    override fun dispatch(context: CoroutineContext, block: Runnable) {
+        default.dispatch(context, block)
+    }
+
+    @InternalCoroutinesApi
+    override fun dispatchYield(context: CoroutineContext, block: Runnable) {
+        default.dispatchYield(context, block)
+    }
+
+    override fun close() {
+        error("Cannot be invoked on Dispatchers.IO")
+    }
+
+    override fun toString(): String = "Dispatchers.IO"
+}