Quelles sont les méthodes pour créer un flux dans…

En Android, vous pouvez créer des threads de plusieurs manières :

En héritant de Thread :

// Classe héritant de Thread
class MyThread extends Thread {
    @Override
    public void run() {
        // Code de la tâche exécutée dans le nouveau thread
        System.out.println("Thread créé par héritage de Thread");
    }
}
// Création et démarrage du thread
MyThread myThread = new MyThread();
myThread.start();

En implémentant l'interface Runnable :

// Classe implémentant Runnable
class MyRunnable implements Runnable {
    @Override
    public void run() {
        // Code de la tâche exécutée dans le nouveau thread
        System.out.println("Thread créé par implémentation de Runnable");
    }
}
// Création du thread avec Runnable
Thread thread = new Thread(new MyRunnable());
thread.start();

Utilisation de AsyncTask (obsolète) : pour exécuter des opérations en arrière-plan et mettre à jour l'UI.

Utilisation de HandlerThread : une classe spéciale de Thread avec Looper et Handler, facilitant la gestion de la file de messages dans un thread en arrière-plan.

// Création de HandlerThread
HandlerThread handlerThread = new HandlerThread("MyHandlerThread");
handlerThread.start();
// Obtention du Looper
Looper looper = handlerThread.getLooper();
// Création d'un Handler lié au Looper
Handler handler = new Handler(looper);
// Envoi d'une tâche dans la file du thread
handler.post(new Runnable() {
    @Override
    public void run() {
        // Code de la tâche exécutée dans handlerThread
        System.out.println("Thread créé avec HandlerThread");
    }
});

Utilisation de ExecutorService et ThreadPoolExecutor : pour gérer un pool de threads.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

// Création d'un pool de threads avec taille fixe
ExecutorService executor = Executors.newFixedThreadPool(2);
// Envoi d'une tâche pour exécution dans le pool
executor.execute(new Runnable() {
    @Override
    public void run() {
        // Code de la tâche dans un des threads du pool
        System.out.println("Thread créé avec ExecutorService");
    }
});
// Arrêt du pool (important pour éviter les fuites)
executor.shutdown();

Utilisation de coroutines Kotlin : approche moderne pour la programmation asynchrone en Android.

import kotlinx.coroutines.*

// Lancer une coroutine dans un thread en arrière-plan
GlobalScope.launch(Dispatchers.IO) {
    // Code de la tâche exécutée dans un thread en arrière-plan (IO)
    println("Thread créé avec coroutines")
}

Quelles sont les méthodes pour créer un flux dans Android?