Usando corutinas nativas en Java

Muchos idiomas modernos admiten trabajar con corutinas a nivel de idioma. Actualmente, Java no admite corutinas, pero existe la esperanza de que las cosas puedan cambiar en el futuro.

En C ++ 20, se planea introducir soporte para trabajar con corutinas.
Usando JNI podemos escribir corutinas en C ++ y usar en código Java.

Consideremos qué corutinas nativas se pueden escribir y cómo usarlas en el código Java.

El generador le permite crear una secuencia de valores de un tipo determinado, mientras que los valores se generan de forma perezosa y sincrónica.

/* C++ code */ generator<int> generate(int count) { for (int i = 0; i < count; i++) { co_yield i; } } 

  /* Java code */ Generator<Integer> gen1 = Coroutine.yield(5); Generator<Float> gen2 = Coroutine.yield(1f, 5); Generator<Double> gen3 = Coroutine.yield(v -> v * 2, 1d, 5); for (int item : gen1) { System.out.println("yield value: " + item); } 

Asynchronous Generator le permite crear una secuencia de valores de un tipo determinado, mientras que los valores se generan de manera lenta y asincrónica.

  /* C++ code */ async_generator<int> generate(int count) { for (int i = 0; i < count; i++) { co_await 1s; co_yield i; } } 

  /* Java code */ Generator<Integer> gen1 = Coroutine.yieldAsync(5); Generator<Float> gen2 = Coroutine.yieldAsync(1f, 5); Generator<Double> gen3 = Coroutine.yieldAsync(v -> v * 2, 1d, 5); for (int item : gen1) { System.out.println("yield value: " + item); } 

La tarea realiza un cálculo asincrónico, que se realiza perezosamente, mientras que la rutina no se ejecuta hasta que la tarea se inicia explícitamente.

Las corutinas se pueden usar como flujos de luz. En este caso, el número de subprocesos en ejecución en el sistema puede ser limitado, por ejemplo, no más de 1000. Y la rutina puede ejecutarse tanto como desee.

Al comenzar una rutina, se verifica si está lista. De lo contrario, la rutina se detiene y el sistema operativo le pasa el controlador. En este punto, se ejecuta una pieza útil de código. Cuando la corutina está lista, se realiza la renovación de la misma.

  /* C++ code */ struct awaiter { bool await_ready() const { return false; } void await_resume() {} void await_suspend(std::coroutine_handle<> handler) { /* invoke java/jni code */ if (!handler.done()) { handler.resume(); } } }; co_await awaiter{}; 

Como cuando se inicia un hilo, puede pasar Runnable o Callable a una corutina.

  /* Java code */ Coroutine.await(() -> { int sum = 5 + 10; }); Task<Integer> task = Coroutine.await(() -> { int sum = 5 + 10; return sum; }); 

El temporizador detiene la tarea actual durante la duración requerida.

  auto operator co_await(const std::chrono::system_clock::duration& duration) { return timer{duration}; } co_await 10ms; 

Se puede usar como reemplazo de Thread.sleep ().

  Coroutine.await(10, TimeUnit.MILLISECONDS); 

Las corutinas también se pueden usar para escribir código sin bloqueo para trabajar con el sistema de archivos, la red, etc.

Como puede ver, las corutinas facilitan la escritura de código asincrónico, permitiendo que partes del código se ejecuten sin bloquear la transmisión.

Las corutinas que planean comenzar en C ++ 20 aparecerán como características de lenguaje puro.
Se planea agregar generadores, tareas y otras rutinas al estándar C ++ 23 o posterior.
Puede escribir sus propias corutinas usted mismo o usar una biblioteca preparada, por ejemplo, cppcoro .

Los compiladores MVSC, Clang ya admiten corutinas como una extensión, y GCC solo está en la etapa de desarrollo.

El código fuente completo se puede ver en github: code