Difference between launch and join in Kotlin

Key takeaways:

• The launch function initiates a new coroutine and is typically used for fire-and-forget scenarios. It allows the program to continue running without waiting for the coroutine to finish, making it ideal for non-blocking operations.

• In contrast, the join function is a suspending function that waits for a coroutine to complete. It ensures that subsequent code execution occurs only after the specified coroutine has finished, allowing for a controlled execution flow.

• Using launch allows the main thread to remain active while the coroutine runs concurrently, whereas join blocks the main thread until the coroutine finishes. This distinction is vital for designing applications with optimal performance and responsiveness.

• The launch function returns a Job object that manages the life cycle of the coroutine, while join does not return any result but instead pauses execution to ensure that the coroutine completes.

In Kotlin coroutines, the launch and join functions are fundamental to managing asynchronous tasks but serve different purposes. Understanding when and how to use each can significantly affect the behavior of your concurrent applications.

What is the launch function?

The launch function is used to start a new coroutine. A coroutine builder returns a Job, representing the coroutine’s life cycle, but does not carry any result of the coroutine execution itself. launch is generally used for fire-and-forget coroutines, where you do not need to return any result to the caller. You just want some action performed asynchronously.

Implementation of the launch function

Here is an example of using launch:

• Line 1: package project

  • Defines the package name for the Kotlin project, which is project.

• Line 2: import kotlinx.coroutines.*

  • Imports all the necessary coroutine utilities from the kotlinx.coroutines package, allowing the use of coroutines, launch, and delay.

• Line 5: println("Main Thread: ${Thread.currentThread().name}")

  • Prints the name of the main thread, indicating which thread the main function is running on.

• Line 8: val job = GlobalScope.launch {

  • Launches a coroutine in the global scope using GlobalScope.launch.

  • job is a reference to the coroutine that is created, though it is not used in this case.

• Line 9: println("Coroutine: ${Thread.currentThread().name}")

  • Prints the name of the thread in which the coroutine is running.

• Line 10: delay(1000)

  • Pauses the coroutine execution for 1000 milliseconds (1 second) to simulate some asynchronous work. The delay function is a non-blocking suspension, meaning it doesn’t block the underlying thread.

• Line 11: println("Coroutine finished")

  • Prints a message indicating that the coroutine has completed its work after the delay.

• Line 14: println("After launching coroutine")

  • Prints a message to the console after launching the coroutine, indicating that the main thread continues running while the coroutine is executing asynchronously.

• Line 17: Thread.sleep(2000)

  • Puts the main thread to sleep for 2000 milliseconds (2 seconds) to give enough time for the coroutine to complete before the program terminates.

What is the join function?

The join is a suspending function used to await the completion of a coroutine. When we call join function on a coroutine, it suspends the current running coroutine (or thread if we’re not already in a coroutine) until the coroutine being joined finishes its execution. This signifies that join pauses the current execution until the coroutine finishes.

Implementation of the join function

Here is an example of using join:

• Line 1: package project

  • Defines the package name for the Kotlin project, which is project.

• Line 2: import kotlinx.coroutines.*

  • Imports all necessary coroutine utilities from the kotlinx.coroutines package, enabling coroutine functions like launch, delay, runBlocking, and join.

• Line 5: println("Main thread: ${Thread.currentThread().name}")

  • Prints the name of the main thread, showing the thread on which the main function is running.

• Line 8: val job = GlobalScope.launch {

  • Launches a new coroutine in the global scope using GlobalScope.launch and assigns the coroutine job to the job variable. The job represents the coroutine’s lifecycle.

• Line 9: println("Coroutine: ${Thread.currentThread().name}")

  • Prints the name of the thread in which the coroutine is executing.

• Line 10: delay(1000)

  • Suspends the coroutine for 1000 milliseconds (1 second) to simulate some asynchronous work. This doesn’t block the main thread.

• Line 11: println("Coroutine finished")

  • Prints a message indicating that the coroutine has completed its work after the delay.

• Line 14: println("After launching coroutine")

  • Prints a message after the coroutine is launched, showing that the main thread continues running while the coroutine is executing.

• Line 17: runBlocking {

  • Starts a runBlocking block, which runs in the main thread and blocks it until the coroutine completes. This allows for waiting in the main function.

• Line 18: job.join()

  • Suspends the runBlocking block until the job coroutine has completed its execution. The join function ensures that the main thread waits for the coroutine to finish.

• Line 21: println("After coroutine has finished")

  • Prints a message indicating that the coroutine has finished, and the program execution can continue after waiting for the coroutine.

Differences between launch and join in Kotlin

Here’s a table summarizing the three main differences between the launch and join functions in Kotlin coroutines:

Quiz

Test your understanding.

Conclusion

In the launch function, the main thread continues its execution immediately after launching the coroutine. On the other hand, the join function blocks the main thread until the coroutine completes its execution, ensuring that the message “After coroutine has finished” is printed only after the coroutine has been completed.