如何在 Kotlin 中获取协程的名称？

Question

I'm curious about the internal working of a coroutine when suspended on the main thread. The real question is how to log a suspended function which is a coroutine on the main thread. Where exactly the execution is taking place? Is it a virtual thread?

Answer 1

If you are talking about logging the coroutine name:

You can achieve this by

1. Give name to coroutine(if you want custom name): launch(CoroutineName("My-Coroutine"))

2. Enable the logging in IntelliJ toolbar menu: Run -> Edit Configuration and add

-Dkotlinx.coroutines.debug in VM options.

Then you can see @My-Coroutine in logcat.

Try below code after Edit Configuration change:

fun main() = runBlocking {
println("   'runBlocking': I'm working in thread ${Thread.currentThread().name}")

val job = launch(CoroutineName("my-custom-name")) {
    println("   'runBlocking': I'm working in thread ${Thread.currentThread().name}")

}

job.join()}

Result:

Answer 2

The other answers don't answer the question directly " How to get the name of a coroutine in Kotlin? "; instead, they suggest how to name a coroutine.

If inside a coroutine, the name can be retrieved using currentCoroutineContext()[CoroutineName] .

If outside a coroutine, there's no direct way to retrieve the name using a reference to a Job or Deferred (too bad). However, there's a reflection hack that can be used. Of course, the usual warnings come attached, which are, no type safety and hacking into internal APIs that may change anytime.

@Suppress("UNCHECKED_CAST")
val nameString = AbstractCoroutine::class.memberFunctions
    .single { it.name == "nameString" } as Function1<AbstractCoroutine<*>, String>
val name = nameString(job as AbstractCoroutine<*>)
    .replace("\"", "")
    .takeWhile { it != '#' }

The method/function containing this code has to be marked with @InternalCoroutinesApi .

Answer 3

You can give name to coroutine using CoroutineName(name:String) method at the time of creating coroutine:

repeat(5) {
            GlobalScope.launch(CoroutineName("$it")) {
                displayGreetingsFor(it)
            }
        }

To retrive the name given to coroutine use coroutineContext[CoroutineName.Key] as shown below:

private suspend fun displayGreetingsFor(i: Int) {
        delay(100)
        println(
            " ${coroutineContext[CoroutineName.Key]} is executing on thread : ${Thread.currentThread().name}"
        )
    }

This is will print following o/p on console:

CoroutineName(0) is executing on thread : DefaultDispatcher-worker-3
CoroutineName(1) is executing on thread : DefaultDispatcher-worker-2
CoroutineName(2) is executing on thread : DefaultDispatcher-worker-8
CoroutineName(3) is executing on thread : DefaultDispatcher-worker-6
CoroutineName(4) is executing on thread : DefaultDispatcher-worker-5

Answer 4

Here is a sample from docs and i guess this is closest you can get.

import kotlinx.coroutines.*

fun main() = runBlocking<Unit> {
    launch { // context of the parent, main runBlocking coroutine
        println("main runBlocking      : I'm working in thread ${Thread.currentThread().name}")
    }
    launch(Dispatchers.Unconfined) { // not confined -- will work with main thread
        println("Unconfined            : I'm working in thread ${Thread.currentThread().name}")
    }
    launch(Dispatchers.Default) { // will get dispatched to DefaultDispatcher 
        println("Default               : I'm working in thread ${Thread.currentThread().name}")
    }
    launch(newSingleThreadContext("MyOwnThread")) { // will get its own new thread
        println("newSingleThreadContext: I'm working in thread ${Thread.currentThread().name}")
    }    
}

will print this.

Unconfined            : I'm working in thread main
Default               : I'm working in thread DefaultDispatcher-worker-1
newSingleThreadContext: I'm working in thread MyOwnThread
main runBlocking      : I'm working in thread main

Read more here