¿Cómo implementar corrutinas en Java?

¿Qué es una rutina?

Coroutine es un subproceso liviano en modo de usuario, que puede implementar la ejecución simultánea de múltiples tareas en un solo subproceso. En comparación con los subprocesos tradicionales, las corrutinas tienen menos sobrecarga de conmutación, por lo que pueden lograr un mayor rendimiento de concurrencia.

Las rutinas pueden verse como un mecanismo multitarea cooperativo. En una rutina, las tareas cooperan a través de un planificador de rutinas. Cuando una tarea necesita esperar a que se complete la operación de E/S, cederá activamente tiempo de CPU a otras tareas y reanudará la ejecución hasta que se complete la operación de E/S.

¿Cómo implementar corrutinas en Java?

En Java, la implementación de corrutinas generalmente requiere el uso de bibliotecas de terceros. Las siguientes son dos bibliotecas de rutinas de Java comúnmente utilizadas:

Quásar

Quasar es una biblioteca de corrutinas basada en JVM que implementa corrutinas a través de mejoras de bytecode. Quasar proporciona una clase llamada Fiber para representar corrutinas, que se pueden usar para crear, iniciar, pausar, reanudar, cancelar, esperar y sincronizar corrutinas a través de la API de Fiber.

El siguiente es un código de muestra que usa Quasar para implementar rutinas:

import co.paralleluniverse.fibers.Fiber;
import co.paralleluniverse.fibers.SuspendExecution;

public class FiberDemo {
    
    
    public static void main(String[] args) throws Exception {
    
    
        Fiber<Void> fiber1 = new Fiber<Void>() {
    
    
            @Override
            protected Void run() throws SuspendExecution, InterruptedException {
    
    
                System.out.println("Fiber 1 started");
                Fiber.sleep(1000);
                System.out.println("Fiber 1 resumed");
                return null;
            }
        };
        
        Fiber<Void> fiber2 = new Fiber<Void>() {
    
    
            @Override
            protected Void run() throws SuspendExecution, InterruptedException {
    
    
                System.out.println("Fiber 2 started");
                Fiber.sleep(500);
                System.out.println("Fiber 2 resumed");
                return null;
            }
        };
        
        fiber1.start();
        fiber2.start();
        
        fiber1.join();
        fiber2.join();
    }
}

En el código anterior, creamos una corrutina al heredar la clase Fiber. En el método de ejecución, podemos escribir el código que necesita ejecutar la corrutina. Con el método Fiber.sleep, podemos suspender la rutina por un período de tiempo y luego reanudar la ejecución. Al final, esperamos a que la corrutina termine de ejecutarse con el método fiber.join.

Corrutinas de Kotlin

Kotlin coroutine es una biblioteca de corrutinas incorporada en lenguaje Kotlin, y su diseño de API es muy simple y fácil de usar. Las rutinas de Kotlin marcan las funciones suspendibles con la palabra clave suspend y usan la clase CoroutineScope para administrar el ciclo de vida de las rutinas.

Aquí hay un código de muestra para implementar corrutinas usando corrutinas Kotlin:

import kotlinx.coroutines.*

fun main() = runBlocking {
    
    
    val job1 = launch {
    
    
        println("Coroutine 1 started")
        delay(1000)
        println("Coroutine 1 resumed")
    }
    
    val job2 = launch {
    
    
        println("Coroutine 2 started")
        delay(500)
        println("Coroutine 2 resumed")
    }
    
    job1.join()
    job2.join()
}

En el código anterior, usamos la función runBlocking para crear un objeto CoroutineScope y luego usamos la función de lanzamiento para crear la corrutina. En la rutina, usamos la función de retraso para hacer que la rutina haga una pausa durante un período de tiempo y luego reanude la ejecución. Al final, usamos la función de unión para esperar a que la rutina termine de ejecutarse.

Resumir

Una rutina es un subproceso ligero que puede lograr un mayor rendimiento de concurrencia. En Java, podemos usar bibliotecas de terceros para implementar rutinas. Quasar es una biblioteca de corrutinas basada en JVM, que implementa corrutinas a través de la mejora del código de bytes; Kotlin coroutine es una biblioteca de corrutinas integrada en lenguaje Kotlin, y su diseño de API es muy simple y fácil de usar. Independientemente de la biblioteca de corrutinas que usemos, debemos prestar atención al ciclo de vida de las corrutinas para evitar problemas como fugas de recursos o interbloqueos.