Java 21 and the long-awaited production-ready Java Virtual Threads that Project Loom promised us a long time ago are here. Why is this important? Like Kotlin Coroutines, they make better use of threads by multiplexing different instructions into different Threads and optimizing runtime in a non-blocking fashion resulting in faster and more resilient services capable of processing larger amounts of data. Kotlin coroutines used to be the only way to do this in the JVM, but with Virtual Threads, the code seems simpler, and where in Kotlin Coroutines we would need to define scopes and sometimes create complex nested code, with Java Virtual Threads, all of that complexity is gone. But there are caveats to this and maybe Kotlin Coroutines still have a specific purpose when developing performant and maintainable code especially when talking about structured concurrency.

With my examples similar to real-life scenarios from my experience, you'll see where and how one usage can be beneficial to the detriment of the other. When you leave this session you'll have learned where are the differences between Java Virtual Threads and Kotlin Coroutines and how to correctly and efficiently apply them.