Tengo la pregunta de este código.
https://kotlinlang.org/docs/reference/coroutines/basics.html
fun main() { GlobalScope.launch { // launch new coroutine in background and continue delay(1000L) // non-blocking delay for 1 second (default time unit is ms) println("World!") // print after delay } println("Hello,") // main thread continues while coroutine is delayed Thread.sleep(2000L) // block main thread for 2 seconds to keep JVM alive }Reemplazo retraso (1000L) con Thread.sleep (1000L). Si el bloque GlobalScope.launch se ejecutará en el mismo subproceso, Thread.sleep(1000L) bloqueará el subproceso. Sin embargo parece que no.
fun main() { GlobalScope.launch { // launch new coroutine in background and continue Thread.sleep(1000L) println("World!") } println("Hello,") // Thread.sleep(2000L) // block main thread for 2 seconds to keep JVM alive }El GlobalScope le permite iniciar corrutinas que más o menos tienen el mismo comportamiento que los subprocesos de daemon , ya que están separados de cualquier Coroutine- Job y básicamente se ejecutan tanto como la aplicación. Su ciclo de vida solo está limitado por la propia aplicación. Esto es algo que desea evitar mediante el uso de " concurrencia estructurada ", lo que básicamente significa que sus rutinas deben anidarse de manera que pueda controlarlas sin realizar un seguimiento manual de sus referencias y unirlas, por ejemplo, para esperar sus cálculos. Entonces, en su código de la vida real, debe evitar GlobalScope tanto como sea posible, ya que ciertamente hay una solución mejor.
En cuanto a su pregunta, y como ya se mencionó, GlobalScope se ejecuta en el grupo Dispatchers.Default , lo que significa que bloqueará algunos subprocesos de trabajo, pero no el que generó la corrutina.
Por otro lado, si tuvieras que escribir este bloque:
fun main() { runBlocking { Thread.sleep(1000L) println("World!") } println("Hello,") Thread.sleep(2000L) } verá que la corrutina bloquea el hilo main y la salida mostrará un resultado diferente. Esto se debe a que runBlocking se ejecuta en el subproceso main de la persona que llama en lugar de en uno de los subprocesos del grupo de trabajadores.
GlobalScope.launch { } no necesariamente creará un nuevo subproceso, pero utilizará uno de un grupo compartido porque utiliza el despachador Default . Entonces, en lo que respecta a su pregunta, en su fragmento, el bloque pasado para iniciar se ejecuta en un hilo diferente.
En la documentación sobre despachadores e hilos , encontrarás lo siguiente:
El despachador predeterminado, que se usa cuando se lanzan corrutinas en GlobalScope, está representado por Dispatchers.Default y usa un grupo de subprocesos de fondo compartido
Y en el documento Dispatchers.Default , puede encontrar:
De forma predeterminada, el nivel máximo de paralelismo utilizado por este despachador es igual al número de núcleos de CPU, pero es al menos dos. El nivel de paralelismo X garantiza que no se pueden ejecutar más de X tareas en este despachador en paralelo.
Tenga en cuenta que puede cambiar el despachador proporcionando uno como parámetro de launch .
La GlobalScope.launch{..} no se bloqueará. Devuelve un objeto Job , que puede usar para esperar un resultado.
Detrás de escena, GlobalScope usa el despachador predeterminado Dispatchers.Default . Puede verlo, por ejemplo, imprimiendo un nombre de hilo dentro de una función de launch{..} .
Deberá ejecutar más rutinas para ver cómo se bloquean entre sí debido a las llamadas Thread.sleep .
https://kotlinlang.org/docs/reference/coroutines/coroutine-context-and-dispatchers.html