Comprendre les coroutines Kotlin

Name: Comprendre les coroutines Kotlin
Author: David Powers

Terminez votre parcours de codage Kotlin avec ce cours avancé

Preview the first lesson free — get full access to all 6 lessons.

Cours : à la demande

Bonjour. Et bienvenue. Dans cette leçon, vous apprendrez les bases des coroutines. Alors, que sont les coroutines et pourquoi en avons-nous besoin ? En d'autres termes, quel est le problème ? Le problème dans le développement de logiciels est donc le manque de temps. C'est des calculs lourds, c'est une bande passante lourde, c'est un traitement lent et des retards. Donc le but dans les coroutines pour Kotlin. Et la raison pour laquelle Kotlin et les développeurs ont construit des coroutines est de contourner les retards. Les coroutines sont donc une approche à plusieurs volets et à plusieurs threads à un mur de briques numériques. D'accord, donc quand une application est lancée comme ça surCreate, la première chose qui se passe est la construction onCreate un thread par défaut, et ce thread est appelé le thread principal. Et ce fil principal marche très bien quand il fait des opérations légères, comme l'utilisateur clique sur un bouton ou tout type d'interaction avec l'utilisateur. Et ça marche très bien quand ça fait des mathématiques simples opérations ou opérations logiques simples. Mais le problème survient lorsque le fil rencontre une opération lourde, comme aller à l'encontre d'internet, peut-être un réseau lent, ou il doit obtenir un fichier d'une base de données, ensuite, il doit analyser toutes les données et indexer toutes les données. Peut-être qu'il doit exécuter une requête de base de données ou il télécharge ou télécharge une sorte d'image Internet ou le serveur de quelqu'un d'autre, ou il télécharge simplement une énorme quantité de données. Ainsi, lorsque nous avons ces opérations lourdes, le fil deviendra bloqué et il faire en sorte que notre application s'y accroche. Et puis l'utilisateur est frustré parce que ils ne savent pas ce qui se passe. Tout ce qu'ils savent, c'est que leur application est bloquée. L'application ralentit. Et s'il y reste longtemps, il pourrait éventuellement tomber en panne. Alors que fait-on pour résoudre ce problème ? Nous devons le débloquer, et c'est là que les coroutines entrent en jeu. Par exemple, une façon dont une coroutine se déplace ce problème est appelé blocage d'exécution. Une autre façon consiste à mettre le fil en mode veille. Alors pour contourner ce problème, ce que nous devons faire est de créer un autre fil, peut-être un thread d'arrière-plan ou plusieurs threads, mais nous devons être prudents car créer tous ces fils consomme beaucoup de mémoire informatique. Et si votre appareil manque de mémoire, c'est tout, ça va planter. Alors les gens de Kotlin ont inventé les coroutines, et vous pouvez exécuter cette coroutine sur toute tâche de longue durée nécessitant des calculs lourds. Et vous pouvez également invoquer des coroutines qui peuvent être suspendues afin que vous puissiez effectuer ces lourdes tâches sans interférer avec le fil principal et en utilisant toute votre mémoire. Alors qu'est-ce qu'une coroutine exactement. Coroutine est par essence, un fil très léger que vous pouvez suspendre ou exécuter au-dessus d'autres threads. Ainsi, lorsque la coroutine est suspendue, tout ce calcul sera mis en pause et supprimé du thread qui utilise la mémoire. Et puis ce fil peut être libéré et utilisé à d'autres fins. Et cela ne rongera pas votre mémoire. Ces coroutines peuvent s'exécuter simultanément, comme nous le voyons ici lancer le travail un et le travail deux, le travail trois et le travail quatre simultanément. Et ces coroutines peuvent communiquer entre elles et même attendre qu'un autre se termine. Ces coroutines fonctionnent toutes ensemble comme une seule unité faire des tâches distinctes. Ainsi, les coroutines peuvent faire une pause ou retarder, puis reprenez quand vous le souhaitez. Vous pouvez avoir un contrôle total sur le moment où la coroutine démarre et s'arrête et fait une pause en lui donnant des limites de temps et des paramètres de temps. Donc on peut prendre un boulot ou une coroutine, et le démarrer et l'arrêter et le mettre en pause et le reprendre et l'annuler quand nous le voulons. Donc, quelques concepts importants dans la coroutine est le concept de portée. Chaque coroutine a sa propre portée que nous pouvons gérer. Certaines coroutines ou globales. D'autres coroutines n'invoquent que dans une zone locale. Un autre concept important dans les coroutines est le contexte de cette coroutine. Quelles sont les variables et quelles sont les entrées et qu'est-ce qui est les données à l'intérieur de la coroutine qui donne une coroutine son caractère, son maquillage ? Tout cela est connu sous le nom de contexte coroutine. Un autre concept important de la coroutine c'est ainsi qu'il peut être suspendu. Exécutons-nous toute la routine ? A quoi cette routine peut-elle être suspendue comme nous les appelons ? Un autre concept important des coroutines est le travail, ou la tâche qui s'exécute à ce moment. Les emplois sont un moyen de gérer nos tâches et la gestion de nos coroutines, parce que nous pourrions vouloir passer une coroutine certains paramètres, puis renvoyez ces paramètres à utiliser pour le prochain travail. D'accord, ce sont les concepts de base des fonctionnalités dont nous avons besoin pour les coroutines. Voilà qui conclut notre leçon sur les fondamentaux de la coroutine. Merci d'avoir regardé. Restez à l'écoute pour la prochaine leçon. Alors allons-y.

Avancé Fournisseur : David Powers 6 leçons · 41m en Arabe, Allemand, Anglais, Espagnol, Français, Portugais, Chinese

Description du cours

des formes de langage dont vous aurez besoin pour créer une coroutine Kotlin. Vous apprendrez la différence entre une routine régulière et une coroutine, et comment la portée et le contexte d’une coroutine peuvent affecter votre programme de kotlin.

Objectifs de la formation :

Ce que vous allez apprendre

Créer une coroutine Kotlin à l'aide de la fonctionnalité courante de construction de coroutines du langage
Distinguer une routine classique d'une coroutine
Démarrer des coroutines en utilisant le lancement de coroutine (coroutine launch)
Appliquer les concepts de portée de coroutine (coroutine scope) et de contexte de coroutine (coroutine context)
Expliquer comment la portée et le contexte d'une coroutine peuvent affecter votre programme Kotlin
Passer en revue les fondamentaux et les concepts importants des coroutines

Points clés à retenir

Le cours couvre les principes fondamentaux des coroutines et les formes de langage nécessaires pour créer une coroutine Kotlin.
Il explique la différence entre une routine classique et une coroutine.
Il montre comment la portée et le contexte d'une coroutine peuvent affecter un programme Kotlin.
Il enseigne comment utiliser le lancement de coroutine (coroutine launch) pour démarrer les coroutines.
Il introduit les concepts importants de portée et de contexte de coroutine.

Foire aux questions

Que couvre ce cours ?

Il couvre les principes fondamentaux des coroutines et les formes de langage nécessaires pour créer une coroutine Kotlin, y compris la différence entre une routine normale et une coroutine et comment la portée et le contexte de la coroutine peuvent affecter votre programme Kotlin.

Qu'est-ce que je vais apprendre sur le démarrage des coroutines ?

Vous apprendrez comment utiliser le lancement de coroutine (coroutine launch) pour démarrer vos coroutines.

Quelles leçons sont incluses ?

Les leçons sont : Principes Fondamentaux des Coroutines ; Routines vs Coroutines Partie 1 ; Routines vs Coroutines Partie 2 ; Lancement de Coroutine (Coroutine Launch) ; Portée de Coroutine (Coroutine Scope) ; et Contexte de Coroutine (Coroutine Context).

À quelles compétences ce cours se rapporte-t-il ?

Il se rapporte à des compétences telles que Kotlin, Coroutine, Concepts de Programmation, Programmation Naturelle, Fondamentaux C#, et Fondamentaux C++.