Continuaciones en java
continuations (11)
¡Jugar! La versión 1.2.x de framework también tiene soporte para continuaciones integradas con productos async http goodies.
Tenga en cuenta que las continuaciones de Play 1.2.x solo funcionan con el servidor Netty incorporado .
Y Play 2.x todavía no tiene soporte para las continuaciones .
¿Hay una buena implementación de continuaciones en Java?
Si es así, ¿cómo es la sobrecarga? La JVM no fue diseñada con este tipo de cosas en mente, ¿verdad? Entonces, ¿esto es ir contra el grano?
Considere también Kotlin Coroutines .
Se implemented través de transformaciones de CPS potencialmente más eficaces ( aún apilables ) y puede usar cualquier ejecutor asíncrono bajo el capó como ForkJoinPool o la integración de Quasar .
Viene con la útil library guided .
Cuidado con algunas trampas de tooling y la reflection .
Consulte Apache Javaflow http://commons.apache.org/sandbox/javaflow/
Es el único paquete de continuación para Java que está activamente en desarrollo. El otro, RIFE, no estoy seguro de en qué estado se encuentra.
Javaflow http://commons.apache.org/sandbox/javaflow/ Play framework use Javaflow http://blog.heroku.com/archives/2011/8/29/play/
RIFE http://www.artima.com/lejava/articles/continuations.html Uso de WebWork.
JauVM http://jauvm.blogspot.com/2005/07/so-what-does-it-do.html JVM en JVM, implementa llamada / continuación de cola
Scala 2.8 http://www.scala-lang.org/node/2096
Cocoon http://cocoon.apache.org/2.1/userdocs/flow/continuations.html http://wiki.apache.org/cocoon/RhinoWithContinuations
Jetty http://docs.codehaus.org/display/JETTY/Continuations volver a intentar la solicitud.
coroutines http://code.google.com/p/coroutines
jconts https://github.com/idubrov/jconts
jyield http://code.google.com/p/jyield
Kilim http://www.malhar.net/sriram/kilim/thread_of_ones_own.pdf
Otra biblioteca de Matthias Mann:
Otro competidor fuerte ha aparecido recientemente.
Quasar aplicaciones de Quasar forked de la implementación de Java de Matthias Mann para proporcionar funciones de nivel superior, como hilos ligeros , actors tipo Erlang y channels y channels tipo Go-like.
Hay muchos puntos de referencia e introducciones detalladas en el Blog de Quasar .
También existe una integración lista para usar llamada Comsat apunta a ayudar a crear fácilmente servicios web de alto rendimiento basados en maquinaria de continuación bajo el capó.
Quasar también proporciona una buena API de Kotlin que se presentó en el reciente webinar de JetBrains Quasar: Fibras, canales y actores eficientes y elegantes .
Todo lo mencionado es de código abierto y de uso gratuito.
Ver también http://blog.paralleluniverse.co/2015/08/07/scoped-continuations/
Actualizar
La experiencia de Quasar se usó más tarde como base para el Proyecto Loom, que aims a brindar soporte de continuación directamente a JVM en algún momento más allá de Java 11.
Está en desarrollo activo ahora y ya tiene un prototype alfa en funcionamiento.
Si entiendo esto correctamente, supongo que el problema obvio consiste en desenrollar la pila con instancias de cierre activas. Supongo que un lenguaje con alcance léxico podría, en teoría, descubrir que un marco secundario puede crear una instancia de cierre, identificar aquellos marcos intermedios a los que se hace referencia, y luego podría bloquear esos marcos en lugar de simplemente empujarlos en la pila.
En este sentido, un compilador podría agrupar todas las tramas o todas las tramas primarias de un cierre que haga referencia a un objeto no vinculado globalmente.
Resumen
No creo que la JVM restrinja los cierres más que una máquina real, es solo que luchan contra el paradigma general de la pila y, por lo tanto, generalmente son castigados.
Si no le importan las continuaciones implícitas, Kilim es una excelente opción. Funciona al procesar métodos anotados y generar las continuaciones en el código de bytes para usted. Obviamente, hace mucho más ya que es un marco, pero si desea el rendimiento (excelente) de las continuaciones seguras de subprocesos, vale la pena echarle un vistazo.
Jetty tiene apoyo de continuation . Hay más discusión y algunas muestras en DZone .
No puedo aconsejar sobre las eficiencias o de otro tipo, aparte de decir que el equipo de Mortbay siempre parece estar consciente de tales problemas. Probablemente habrá una discusión sobre las compensaciones de implementación en algún lugar del sitio de Jetty.
Scala también se ejecuta en JVM. Así que podría ser relevante.
¿Qué son las continuaciones de Scala y por qué usarlas?
Además, Scala tiene una característica asíncrona / await algo similar:
Desde Java 8, ahora hay una clase CompletableFuture<T> que admite continuaciones y enfoques de programación más funcionales / reactivos.
Considere el siguiente ejemplo, donde una Clase ofrece un método downloadAndResize :
public CompletableFuture<Image> downloadAndResize(String imageUrl, int width, int height) {
return CompletableFuture
.supplyAsync(() -> downloadImage(imageUrl))
.thenApplyAsync(x -> resizeImage(x, width, height));
}
private Image downloadImage(String url){
// TODO Download the image from the given url...
}
private Image resizeImage(Image source, int width, int height){
// TODO Resize the image to w / h
}
El uso del método anterior podría verse como:
CompletableFuture<Image> imagePromise = downloadAndResize("http://some/url", 300, 200);
imagePromise.thenAccept(image -> {
// Gets executed when the image task has successfully completed
// do something with the image
});