Quels moyens et approches sont utilisés pour mettre en œuvre le multitâche et résoudre les problèmes liés à l'exécution parallèle des tâches?

Pour implémenter la multitâche sur Android et résoudre les problèmes d'exécution parallèle des tâches, plusieurs approches et outils sont utilisés :

1. Thread et Runnable — outils de base de Java pour créer des threads. Permettent d'exécuter des tâches dans des threads séparés, mais nécessitent une gestion manuelle.

2. Handler et Looper — pour échanger des messages entre threads, notamment pour mettre à jour l'interface utilisateur depuis des threads en arrière-plan.

3. AsyncTask (obsolète) — simplifiait l'exécution de tâches en arrière-plan avec mise à jour de l'UI, mais il est maintenant recommandé d'utiliser d'autres outils.

4. Executor et ThreadPoolExecutor — permettent de gérer un pool de threads, aidant à éviter la création d'un nombre excessif de threads.

5. Coroutines (Kotlin) — méthode moderne et pratique pour la programmation asynchrone, simplifiant le travail avec les threads et évitant les problèmes de synchronisation.

6. RxJava — bibliothèque pour la programmation réactive, permettant de travailler facilement avec des flux de données asynchrones.

Pour résoudre les problèmes de parallélisme, on applique :

• Synchronisation (synchronized, ReentrantLock) pour protéger les ressources communes.
• Volatile pour assurer la visibilité des changements entre threads.
• Objets immuables pour éviter les conditions de course.
• Utilisation de collections concurrentes (ConcurrentHashMap, etc.).

Exemple d'utilisation de Kotlin Coroutines pour une tâche en arrière-plan :

import kotlinx.coroutines.*

fun loadData() {
    GlobalScope.launch(Dispatchers.Main) { // lancement sur le thread principal
        val data = withContext(Dispatchers.IO) { // passage au thread en arrière-plan
            // opération lourde, par exemple, chargement depuis le réseau
            fetchDataFromNetwork()
        }
        updateUI(data) // mise à jour de l'UI
    }
}