Continuations in Java

Question

Is there a good implementation of continuations in Java?

If so, what are the overheads? The JVM was not designed with such things, right? So does it go against the grain?

Answer 1

See Apache Javaflow http://commons.apache.org/sandbox/javaflow/

This is the only continuation package for Java that is being actively developed. The other, RIFE, I'm not sure what condition it is in.

Answer 2

Javaflow http://commons.apache.org/sandbox/javaflow/ Use the Javaflow framework http://blog.heroku.com/archives/2011/8/29/play/

RIFE http://www.artima.com/lejava/articles/continuations.html Using WebWork.

JauVM http://jauvm.blogspot.com/2005/07/so-what-does-it-do.html JVM in JVM, implements tail call / continue

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 re-request.

coroutine 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

ATCT http://portal.acm.org/ft_gateway.cfm?id=949362

Answer 3

Jetty has continuation support. The following is a discussion of several examples on DZone .

I cannot advise on performance or otherwise, except to say that the Mortbay team always seems fascinating on such issues. Most likely, there will be a discussion of implementation compromises somewhere on the Jetty website.

Answer 4

If I get it right, I assume the obvious problem is to expand the stack with active instances of closure. I believe that a language with a lexical domain could theoretically figure out that a child frame can instantiate a closure, identify those intermediate frames that are referenced, and then it can malloc these frames instead of just pushing them onto the stack.

In this case, the compiler can malloc all frames or all parent closure frames that reference an object that is not bound to global objects.

Summary

I don’t think the JVM limits the closure more than the real machine, they just struggle with the overall stack paradigm, and therefore they usually get fined.

Answer 5

If you don't mind implicit continuations, Kilim is a great option. It works by processing annotated methods and generating bytecode sequel for you. Obviously, this does a lot more, since it is a framework, but if you want the (excellent) performance of thread-safe continuations, it's worth a look.

Answer 6

Play! framework version 1.2.x also has continuation support integrated with asynchronous http files.

Please note that Play 1.2.x extensions only work with the built-in Netty server .

And Play 2.x still does not support sequels .

Answer 7

Recently, another strong competitor has appeared.

Quasar uses forked from Matthias Mann's implementation of java sequels to provide higher level functions such as lightweight streams , Erlang-like members, and Go-like coroutines and channels .

The Quasar Blog block has many tests and detailed presentations.

There is also a ready-to-use integration called Comsat , which aims to simplify the creation of web services based on continuation mechanisms under the hood.

Quasar also provides the good Kotlin API, which was featured at the recent Quasar JetBrains webinar : efficient and elegant fibers, channels, and actors .

All of the above is open source and free to use.

Answer 8

Scala also runs on the JVM. Therefore, this may be relevant.

What are Scala sequels and why use them?

In addition, Scala has a somewhat similar async / await function:

http://docs.scala-lang.org/sips/pending/async.html

Answer 9

Another Matthias Mann Library:

http://www.matthiasmann.de/content/view/24/26/

http://www.matthiasmann.de/java/Continuations/

Answer 10

Starting with Java 8, there is now the class CompletableFuture<T> , which supports continuation and more functional / reactive programming approaches.

Consider the following example where the class offers the downloadAndResize method:

 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 } 

Using the above method might look like this:

 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 });