Can I take advantage of Kotlin's Coroutines by using them in Java code?

Question

What's my goal?

My goal is to be able to use Kotlin's Coroutine system from Java. I want to be able to pause mid-execution for a given amount of time, and then pick back up at that spot after the given amount of time has passed. From Java, I'd like to be able to execute tasks that allow pausing mid-execution without in an asynchronous fashion, such as:

//example 1
someLogic();
pause(3000L); //3 seconds
someMoreLogic();

//example 2
while(true) {
    someContinuedLogic();
    pause(10000L); //10 seconds
}

What's my issue?

As expected, I am able to execute coroutines perfectly fine from Kotlin, but when it comes to Java, it becomes tricky because the Java part of the code executes the entire block at once without any pauses, whereas the Kotlin block correctly pauses 1, and then 4 seconds.

What's my question?

Is it even possible to use Kotlin as a backbone for coroutines in Java? If so, what am I doing wrong? Below you can find the source code showing how I am attempting to use Kotlin's coroutines in Java.

KtScript Class

abstract class KtScript {

    abstract fun execute()

    fun <T> async(block: suspend () -> T): CompletableFuture<T> {
        val future = CompletableFuture<T>()
        block.startCoroutine(completion = object : Continuation<T> {
            override fun resume(value: T) {
                future.complete(value)
            }
            override fun resumeWithException(exception: Throwable) {
                future.completeExceptionally(exception)
            }
        })
        return future
    }

    suspend fun <T> await(f: CompletableFuture<T>): T =
            suspendCoroutine { c: Continuation<T> ->
                f.whenComplete { result, exception ->
                    if (exception == null)
                        c.resume(result)
                    else
                        c.resumeWithException(exception)
                }
            }

    fun pause(ms: Long): CompletableFuture<*> {
        //todo - a better pausing system (this is just temporary!)
        return CompletableFuture.runAsync {
            val currentMs = System.currentTimeMillis()
            while (System.currentTimeMillis() - currentMs < ms) {
                /* do nothing */
            }
        }
    }

}

Kotlin Execution Code

fun main(args: Array<String>) {
    ScriptTestKotlin().execute()
}

class ScriptTestKotlin : KtScript() {
    override fun execute() {
        println("Executing Kotlin script from Kotlin...")
        val future = async {
            await(pause(1000L))
            println("   1 second passed...")
            await(pause(4000L))
            println("   5 seconds passed...")
        }
        future.get() //wait for asynchronous task to finish
        println("Finished!")
    }
}

Kotlin Execution Results

Executing Kotlin script from Kotlin...
   1 second passed...
   5 seconds passed...
Finished!

Java Execution Code

public class ScriptTestJava extends KtScript {

    public static void main(String[] args) {
        new ScriptTestJava().execute();
    }

    @Override
    public void execute() {
        System.out.println("Executing Kotlin script from Java...");
        CompletableFuture<?> future = async(continuation -> {
            await(pause(1000L), continuation);
            System.out.println("    1 second passed...");
            await(pause(4000L), continuation);
            System.out.println("    5 seconds passed...");
            return continuation;
        });
        try {
            future.get(); //wait for asynchronous task to finish
        } catch(Exception e) {
            e.printStackTrace();
        }
        System.out.println("Finished!");
    }
}

Java Execution Results

Executing Kotlin script from Java...
    1 second passed...
    5 seconds passed...
Finished!

^^^ Unfortunately, the pauses are skipped in Java. ^^^

Why don't you just switch to Kotlin instead?

Adam Arold
– Adam Arold

2018-12-10 08:33:01 +00:00
Commented Dec 10, 2018 at 8:33 — Adam Arold
– Adam Arold, Commented Dec 10, 2018 at 8:33

voddan · Accepted Answer · 2017-01-10 04:30:57Z

28

Kotlin coroutines are implemented with a compiler transformation to the code, which obviously can only be done by kotlinc.

So, no, Java cannot use Kotlin's coroutines mechanic since it is a compile-time feature.

answered Jan 10, 2017 at 4:30

voddan

34.1k9 gold badges83 silver badges89 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

jkratz55 Over a year ago

What if your library is written in Kotlin utilizing coroutines, and included as a JAR in a Java project. Would Java be able to utilize calling methods written in Kotlin that utilize coroutines?

voddan Over a year ago

From the java POV such a library would just look like normal bytecode with callbacks and some method calls to kotlinx.coroutines library classes. So no different than any other asynchronous technique

Collectives™ on Stack Overflow

Can I take advantage of Kotlin's Coroutines by using them in Java code?

1 Answer 1

2 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

2 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related