Unresolved reference 'await' on receiver of type 'Job'
Ai pornit corutina cu launch, care întoarce un Job fără rezultat, și apoi ceri rezultatul cu await(). Dacă îți trebuie o valoare, pornește corutina cu async (întoarce Deferred<T>, care are await()). Dacă vrei doar să aștepți terminarea, folosește join().
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Cele două constructori de corutine au roluri diferite:
launch { }pornește o lucrare „fire and forget” și întoarce unJob. UnJobpoate fi așteptat (join()) sau anulat (cancel()), dar nu are rezultat;async { }pornește o lucrare care produce o valoare și întoarce unDeferred<T>(care este și el unJob). Rezultatul se ia cuawait().
Mesajul spune exact asta: funcția await nu există pe tipul Job. Valoarea ultimei expresii din launch { } e ignorată. Pe lângă eroarea asta, uneori apare și una de inferență pe runBlocking, pentru că rezultatul ultimei linii nu se poate deduce.
De ce apare: cauzele frecvente
1launch în loc de async
import kotlinx.coroutines.*
fun main() = runBlocking {
val pret = launch { 120 }
println(pret.await())
}import kotlinx.coroutines.*
fun main() = runBlocking {
val pret = async { 120 }
println(pret.await())
}async întoarce Deferred<Int>, iar await() dă valoarea 120.
2Voiai doar să aștepți terminarea
import kotlinx.coroutines.*
fun main() = runBlocking {
val job = launch { delay(10); println("salvat") }
job.await()
println("gata")
}import kotlinx.coroutines.*
fun main() = runBlocking {
val job = launch { delay(10); println("salvat") }
job.join()
println("gata")
}join() suspendă până se termină Job-ul, fără să aștepte vreo valoare.
Repară eroarea, direct în pagină
Programul de mai jos calculează în paralel prețul și stocul unui produs, dar nu compilează: Unresolved reference 'await' on receiver of type 'Job'. Repară pornirea corutinelor ca programul să afișeze Pret: 120, stoc: 7.
import kotlinx.coroutines.*
suspend fun pret(): Int { delay(50); return 120 }
suspend fun stoc(): Int { delay(50); return 7 }
fun main() = runBlocking {
val p = launch { pret() }
val s = launch { stoc() }
println("Pret: ${p.await()}, stoc: ${s.await()}")
}Pret: 120, stoc: 7
Indiciu
Corutinele care întorc o valoare se pornesc cu async, nu cu launch.
Reparația
import kotlinx.coroutines.*
suspend fun pret(): Int { delay(50); return 120 }
suspend fun stoc(): Int { delay(50); return 7 }
fun main() = runBlocking {
val p = async { pret() }
val s = async { stoc() }
println("Pret: ${p.await()}, stoc: ${s.await()}")
}De ce merge
launch întoarce un Job, care nu are rezultat și nici funcția await(). Valoarea întoarsă de pret() se pierdea. async întoarce un Deferred<Int>: cele două calcule rulează tot în paralel, iar await() dă fiecare rezultat când e gata, deci afișarea primește 120 și 7.
Alte forme ale mesajului
error: unresolved reference 'await' on receiver of type 'Job'.Unresolved reference: awaitUnresolved reference 'awaitAll' on receiver of type 'List<Job>'
Cum o eviți pe viitor
Alege constructorul după ce ai nevoie: launch pentru efecte (salvare, trimitere, actualizare UI), async pentru calcule care întorc o valoare. Când pornești mai multe calcule în paralel, folosește async pentru fiecare și apoi awaitAll() pe lista de Deferred. Pentru mai multe launch, așteaptă-le cu joinAll().
Întrebări frecvente
Pot folosi async și să nu chem await?
Poți, dar dacă async aruncă o excepție, ea iese la iveală doar la await() (sau anulează scope-ul). Pentru lucrări fără rezultat, launch e alegerea corectă.
Care e diferența între join și await?
Ambele așteaptă terminarea. await() (doar pe Deferred) întoarce și rezultatul sau aruncă excepția corutinei.
Erori înrudite
Unresolved reference 'runBlocking' Folosești runBlocking (sau launch, async, delay) fără importul bibliotecii de corutine. Adaugă sus în fișier import kotlinx.coroutines.* și, într-un proiect Gradle, dependența kotlinx-coroutines-core. launch și async cer în plus să fii într-un CoroutineScope. kotlinx.coroutines.JobCancellationException: DeferredCoroutine was cancelled Ai așteptat (await, join) rezultatul unei corutine care fusese anulată, de tine sau de părintele ei. O corutină anulată nu mai are rezultat, așa că await aruncă excepția. Verifică isCancelled înainte, nu anula ce urmează să folosești, sau tratează CancellationException explicit. Suspend function 'suspend fun delay(timeMillis: Long): Unit' can only be called from a coroutine or another suspend function Apelezi o funcție suspend (delay, o funcție proprie marcată suspend) dintr-o funcție obișnuită. Funcțiile suspend pot fi apelate doar din corutine sau din alte funcții suspend. Marchează și funcția apelantă cu suspend, sau pornește o corutină, de exemplu cu runBlocking { } în main. Învață Kotlin de la zero, cu exerciții la fiecare lecție
Curs Kotlin (Android): lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.
