web-dev-qa-db-fra.com

Différence entre le travail et le report à Coroutines Kotlin

Je suis nouveau dans les coroutines, je comprends le lancement et l'async mais la partie toujours confuse est différée. Qu'est-ce qui est différé? et différent entre le travail et différé. Une explication claire et un exemple sont plus utiles. Merci d'avance

androidkotlindeferredkotlin-coroutines
16
Magesh Pandian

Donc job est une sorte d'objet qui représente l'exécution d'une coroutine et est lié à concurrence simultanée structurée , par ex. vous pouvez annuler un travail et tous les enfants de ce travail seront également annulés.

De docs :

Le travail est une chose annulable avec un cycle de vie qui culmine dans son achèvement.

Deferred est une sorte d'analogue de Future en Java: in encapsule une opération qui sera terminée à un moment donné après son initialisation. Mais est également lié aux coroutines à Kotlin.

De la documentation:

La valeur différée est un avenir annulable non bloquant - c'est un Job qui a un résultat.

Ainsi, Deferred est un Job qui a un résultat:

Une valeur deferred est un Job. Un job dans le générateur coroutineContext du async représente la coroutine elle-même.

Un exemple:

someScope.launch {
    val userJob: Deferred<User> = async(IO) { repository.getUser(id) }
    //some operations, while user is being retrieved 
    val user = userJob.await() //here coroutine will be suspended for a while, and the method `await` is available only from `Deferred` interface
    //do the job with retrieved user
}

En outre, il est possible de structurer cette demande async avec une étendue existante, mais c'est une autre question.

12
Andrey Ilyunin

Au niveau de base, Deferred est un avenir. Il permet à une coroutine d'attendre le résultat produit par une autre, en se suspendant jusqu'à ce qu'elle soit prête. Appeler async est un moyen, mais de loin pas le seul moyen, d'obtenir un Deferred.

Cependant, je pense que votre question concerne davantage les bases: quand utiliser launch, quand utiliser async-await. Voici une leçon importante: vous n'avez probablement pas besoin d'async. Les gens ont tendance à l'utiliser parce que les mots clés async et await sont familiers dans d'autres langues, mais dans Kotlin, async n'est pas un outil à usage général pour réaliser des appels non bloquants .

Voici une recette de base sur la façon de transformer un appel bloquant en un appel suspendu et non bloquant:

uiScope.launch {
    val ioResult = withContext(Dispatchers.IO) { blockingIOCall() }
    ... just use the result, you're on the GUI thread here.
}
6
Marko Topolnik