What is GlobalScope in Kotlin: Simple Explanation and Usage

GlobalScope in Kotlin is a global coroutine scope that lives as long as the application does. It is used to launch coroutines that are not tied to any specific lifecycle or job, meaning they run independently until completion or app shutdown.

How It Works

GlobalScope acts like a global manager for coroutines that are launched without any specific owner or lifecycle. Imagine it as a big room where you can start tasks that keep running no matter what else happens in your app. These tasks will continue until they finish or the whole app closes.

Because GlobalScope is not linked to any particular part of your program, it doesn't automatically stop coroutines if, for example, a screen closes or a user navigates away. This means you have to be careful when using it, as coroutines might keep running longer than you want, potentially causing unexpected behavior or resource use.

Example

This example shows how to launch a coroutine using GlobalScope that prints a message after a delay.

kotlin

import kotlinx.coroutines.*

fun main() {
    println("Start")
    GlobalScope.launch {
        delay(1000L)
        println("Hello from GlobalScope")
    }
    Thread.sleep(1500L) // Keep JVM alive to see coroutine output
    println("End")
}

Output

Start
Hello from GlobalScope
End

When to Use

Use GlobalScope when you want to launch coroutines that should run independently of any specific lifecycle, such as background tasks that must continue regardless of UI changes. For example, logging, analytics, or long-running background jobs that should not be cancelled when a user leaves a screen.

However, avoid using GlobalScope for coroutines tied to UI or short-lived components, because it can cause memory leaks or unexpected behavior if coroutines keep running after the component is gone. Instead, prefer structured concurrency with scopes tied to lifecycle or jobs.

Key Points

• GlobalScope lives as long as the application runs.
• Coroutines launched in GlobalScope are not cancelled automatically.
• Use it for independent, long-running background tasks.
• Avoid it for UI-related or short-lived coroutines to prevent leaks.
• Prefer structured concurrency with custom scopes when possible.

Key Takeaways

GlobalScope launches coroutines that live as long as the app runs.

It is best for background tasks that should not be cancelled automatically.

Avoid using GlobalScope for UI-related coroutines to prevent leaks.

Prefer structured concurrency with lifecycle-aware scopes for most cases.