Change more "create new" to "create a"

Author: Inego

docs/basics.md

@@ -265,7 +265,7 @@ fun main() = runBlocking { // this: CoroutineScope
         println("Task from runBlocking")
     }
 
-    coroutineScope { // Creates a new coroutine scope
+    coroutineScope { // Creates a coroutine scope
         launch {
             delay(500L) 
             println("Task from nested launch")

docs/coroutine-context-and-dispatchers.md

@@ -105,7 +105,7 @@ The default dispatcher, that is used when coroutines are launched in [GlobalScop
 is represented by [Dispatchers.Default] and uses shared background pool of threads,
 so `launch(Dispatchers.Default) { ... }` uses the same dispatcher as `GlobalScope.launch { ... }`.
 
-[newSingleThreadContext] creates a new thread for the coroutine to run. 
+[newSingleThreadContext] creates a thread for the coroutine to run. 
 A dedicated thread is a very expensive resource. 
 In a real application it must be either released, when no longer needed, using [close][ExecutorCoroutineDispatcher.close] 
 function, or stored in a top-level variable and reused throughout the application.  

kotlinx-coroutines-core/common/src/Job.kt

@@ -341,7 +341,7 @@ public interface Job : CoroutineContext.Element {
 }
 
 /**
- * Creates a new job object in an active state.
+ * Creates a job object in an active state.
  * A failure of any child of this job immediately causes this job to fail, too, and cancels the rest of its children.
  *
  * To handle children failure independently of each other use [SupervisorJob].

kotlinx-coroutines-core/common/src/Supervisor.kt

@@ -13,7 +13,7 @@ import kotlin.coroutines.intrinsics.*
 import kotlin.jvm.*
 
 /**
- * Creates a new _supervisor_ job object in an active state.
+ * Creates a _supervisor_ job object in an active state.
  * Children of a supervisor job can fail independently of each other.
  * 
  * A failure or cancellation of a child does not cause the supervisor job to fail and does not affect its other children,

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

@@ -10,7 +10,7 @@ import java.util.concurrent.atomic.AtomicInteger
 import kotlin.coroutines.*
 
 /**
- * Creates a new coroutine execution context using a single thread with built-in [yield] support.
+ * Creates a coroutine execution context using a single thread with built-in [yield] support.
  * **NOTE: The resulting [ExecutorCoroutineDispatcher] owns native resources (its thread).
  * Resources are reclaimed by [ExecutorCoroutineDispatcher.close].**
  *

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

@@ -367,7 +367,7 @@ internal class CoroutineScheduler(
     }
 
     /**
-     * Unparks or creates a new [Worker] for executing non-blocking tasks if there are idle cores
+     * Unparks or creates a [Worker] for executing non-blocking tasks if there are idle cores
      */
     private fun requestCpuWorker() {
         // No CPU available -- nothing to request
@@ -383,7 +383,7 @@ internal class CoroutineScheduler(
          */
         if (tryUnpark()) return
         /*
-         * Create a new thread.
+         * Create a thread.
          * It's not preferable to use 'cpuWorkersCounter' here (moreover, it's implicitly here as corePoolSize - cpuPermits.availableTokens),
          * cpuWorkersCounter doesn't take into account threads which are created (and either running or parked), but haven't
          * CPU token: retiring workers, recently unparked workers before `findTask` call, etc.

kotlinx-coroutines-core/jvm/test/guide/example-basic-04.kt

@@ -13,7 +13,7 @@ fun main() = runBlocking { // this: CoroutineScope
         println("Task from runBlocking")
     }
 
-    coroutineScope { // Creates a new coroutine scope
+    coroutineScope { // Creates a coroutine scope
         launch {
             delay(500L) 
             println("Task from nested launch")