Valeurs de retour des opérations de thread

Dans la programmation multithread, l'interaction entre les threads nécessite souvent l'échange de données. Un scénario courant consiste à tenter de récupérer le résultat d'une opération effectuée dans un thread distinct.

Considérez l'exemple de code ci-dessous :

public void test() {
    Thread uiThread = new HandlerThread("UIHandler") {
        public synchronized void run() {
            int value = 2; // To be returned to test()
        }
    };
    uiThread.start();
}

Dans ce cas, une valeur est modifiée dans un thread distinct (dans ce cas, le "UIHandler"). Le défi consiste à renvoyer cette valeur à la méthode appelante, qui doit récupérer les données modifiées.

Exploiter l'état d'un objet

Une approche de ce problème consiste à utiliser l'état d'un objet pour stocker et récupérer les données requises. Par exemple, vous pouvez créer une classe personnalisée qui implémente l'interface Runnable, lui permettant d'être exécutée en tant que thread. Au sein de cette classe, vous pouvez avoir un champ pour stocker la valeur calculée par le thread :

public class Foo implements Runnable {
    private volatile int value;

    @Override
    public void run() {
        value = 2;
    }

    public int getValue() {
        return value;
    }
}

Avec cette implémentation, vous pouvez séparer la création du thread et la récupération de la valeur calculée. Voici un exemple :

Foo foo = new Foo();
Thread thread = new Thread(foo);
thread.start();
thread.join();
int value = foo.getValue(); // Retrieve the modified value

Considérations clés

Il est important de noter que les threads ne renvoient pas de valeurs de manière native. En référençant un thread comme une classe ordinaire et en demandant sa valeur à l'aide de méthodes comme getValue(), vous pouvez combler cette lacune. De plus, vous devez garantir des mécanismes de synchronisation pour éviter les conditions de concurrence critique dans les données et maintenir la sécurité des threads.