Valeur renvoyée par Thread

J'ai une méthode avec un HandlerThread. Une valeur est modifiée dans le Threadet j'aimerais la renvoyer à la test()méthode. Y a-t-il un moyen de faire cela?

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

Vous pouvez utiliser un tableau de variables final local. La variable doit être de type non primitif, vous pouvez donc utiliser un tableau. Vous devez également synchroniser les deux threads, par exemple à l'aide d'un CountDownLatch :

public void test()
{   
    final CountDownLatch latch = new CountDownLatch(1);
    final int[] value = new int[1];
    Thread uiThread = new HandlerThread("UIHandler"){
        @Override
        public void run(){
            value[0] = 2;
            latch.countDown(); // Release await() in the test thread.
        }
    };
    uiThread.start();
    latch.await(); // Wait for countDown() in the UI thread. Or could uiThread.join();
    // value[0] holds 2 at this point.
}

Vous pouvez également utiliser un Executoret un Callablecomme ceci:

public void test() throws InterruptedException, ExecutionException
{   
    ExecutorService executor = Executors.newSingleThreadExecutor();
    Callable<Integer> callable = new Callable<Integer>() {
        @Override
        public Integer call() {
            return 2;
        }
    };
    Future<Integer> future = executor.submit(callable);
    // future.get() returns 2 or raises an exception if the thread dies, so safer
    executor.shutdown();
}

Habituellement, vous feriez quelque chose comme ça

 public class Foo implements Runnable {
     private volatile int value;

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

     public int getValue() {
         return value;
     }
 }

Ensuite, vous pouvez créer le thread et récupérer la valeur (étant donné que la valeur a été définie)

Foo foo = new Foo();
Thread thread = new Thread(foo);
thread.start();
thread.join();
int value = foo.getValue();

tl;drun thread ne peut pas renvoyer une valeur (du moins pas sans mécanisme de rappel). Vous devez référencer un thread comme une classe ordinaire et demander la valeur.

Ce que vous recherchez est probablement l' Callable<V>interface à la place de Runnable, et la récupération de la valeur avec un Future<V>objet, ce qui vous permet également d'attendre que la valeur ait été calculée. Vous pouvez y parvenir avec un ExecutorService, à partir duquel vous pouvez obtenir Executors.newSingleThreadExecutor().

public void test() {
    int x;
    ExecutorService es = Executors.newSingleThreadExecutor();
    Future<Integer> result = es.submit(new Callable<Integer>() {
        public Integer call() throws Exception {
            // the other thread
            return 2;
        }
    });
    try {
        x = result.get();
    } catch (Exception e) {
        // failed
    }
    es.shutdown();
}

Et cette solution?

Il n'utilise pas la classe Thread, mais il est simultané et, d'une certaine manière, il fait exactement ce que vous demandez

ExecutorService pool = Executors.newFixedThreadPool(2); // creates a pool of threads for the Future to draw from

Future<Integer> value = pool.submit(new Callable<Integer>() {
    @Override
    public Integer call() {return 2;}
});

Maintenant, tout ce que vous faites est de dire value.get()que chaque fois que vous avez besoin de récupérer votre valeur retournée, le thread est lancé à la seconde où vous donnez valueune valeur afin que vous n'ayez jamais à dire là- threadName.start()dessus.

Quelle Futureest, est une promesse au programme, vous promettez le programme que vous obtenez la valeur dont il a besoin dans le futur proche

Si vous l'appelez .get()avant que ce soit fait, le thread qui l'appelle attendra simplement que ce soit terminé

Si vous voulez la valeur de la méthode appelante, alors il doit attendre que le thread se termine, ce qui rend l'utilisation de threads un peu inutile.

Pour répondre directement à votre question, la valeur peut être stockée dans n'importe quel objet mutable auquel la méthode appelante et le thread ont tous deux une référence. Vous pouvez utiliser l'externe this, mais cela ne sera pas particulièrement utile à part pour des exemples triviaux.

Une petite note sur le code dans la question: l'extension Threadest généralement un style médiocre. En effet, étendre les classes inutilement est une mauvaise idée. Je remarque que votre runméthode est synchronisée pour une raison quelconque. Maintenant que l'objet dans ce cas est le, Threadvous pouvez interférer avec tout ce qui Threadutilise son verrou (dans l'implémentation de référence, quelque chose à voir avec join, IIRC).

À partir de Java 8, nous avons CompletableFuture. Dans votre cas, vous pouvez utiliser la méthode supplyAsync pour obtenir le résultat après l'exécution.

Veuillez trouver des réf. ici https://www.baeldung.com/java-completablefuture#Processing

    CompletableFuture<Integer> completableFuture
      = CompletableFuture.supplyAsync(() -> yourMethod());

   completableFuture.get() //gives you the value

L'utilisation de Future décrite dans les réponses ci-dessus fait le travail, mais un peu moins significativement que f.get (), bloque le thread jusqu'à ce qu'il obtienne le résultat, ce qui viole la concurrence.

La meilleure solution est d'utiliser ListenableFuture de Guava. Un exemple :

    ListenableFuture<Void> future = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(1, new NamedThreadFactory).submit(new Callable<Void>()
    {
        @Override
        public Void call() throws Exception
        {
            someBackgroundTask();
        }
    });
    Futures.addCallback(future, new FutureCallback<Long>()
    {
        @Override
        public void onSuccess(Long result)
        {
            doSomething();
        }

        @Override
        public void onFailure(Throwable t)
        {

        }
    };

Avec de petites modifications à votre code, vous pouvez y parvenir de manière plus générique.

 final Handler responseHandler = new Handler(Looper.getMainLooper()){
            @Override
            public void handleMessage(Message msg) {
                //txtView.setText((String) msg.obj);
                Toast.makeText(MainActivity.this,
                        "Result from UIHandlerThread:"+(int)msg.obj,
                        Toast.LENGTH_LONG)
                        .show();
            }
        };

        HandlerThread handlerThread = new HandlerThread("UIHandlerThread"){
            public void run(){
                Integer a = 2;
                Message msg = new Message();
                msg.obj = a;
                responseHandler.sendMessage(msg);
                System.out.println(a);
            }
        };
        handlerThread.start();

Solution :

1. Créez un Handlerthread dans l'interface utilisateur, qui s'appelleresponseHandler
2. Initialisez ceci à Handlerpartir Looperde UI Thread.
3. Dans HandlerThread, publier un message à ce sujetresponseHandler
4. handleMessgaeaffiche une Toastavec valeur reçue du message. Cet objet Message est générique et vous pouvez envoyer différents types d'attributs.

Avec cette approche, vous pouvez envoyer plusieurs valeurs au thread d'interface utilisateur à différents moments. Vous pouvez exécuter (publier) de nombreux Runnableobjets sur celui-ci HandlerThreadet chacun Runnablepeut définir une valeur dans l' Messageobjet, qui peut être reçu par UI Thread.