从线程返回值

我有一个方法HandlerThread。值在内部被更改Thread，我想将其返回给该test()方法。有没有办法做到这一点？

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

您可以使用局部最终变量数组。该变量必须是非基本类型，因此可以使用数组。您还需要同步两个线程，例如使用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.
}

您也可以这样使用an Executor和a Callable：

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();
}

通常你会做这样的事情

 public class Foo implements Runnable {
     private volatile int value;

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

     public int getValue() {
         return value;
     }
 }

然后，您可以创建线程并检索值（假设已设置值）

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

tl;dr线程无法返回值（至少不是没有回调机制）。您应该像普通类一样引用线程并要求其值。

您正在寻找的可能是Callable<V>代替的接口Runnable，并使用一个Future<V>对象检索该值，这也使您可以等待直到计算出值为止。你可以用一个做到这一点ExecutorService，你可以从得到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();
}

这个解决方案怎么样？

它不使用Thread类，但它是并发的，并且在某种程度上可以完全满足您的要求

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;}
});

现在，您要做的就是说，value.get()每当需要获取返回的值时，线程就会在您提供value值的第二秒开始启动，因此您不必threadName.start()在上面说。

什么Future是对程序的承诺，您向程序保证，它将在不久的将来获得所需的价值

如果您.get()在完成之前调用它，那么调用它的线程将只是等待完成

如果要从调用方法中获取该值，则它应等待线程完成，这使得使用线程变得毫无意义。

为了直接回答您的问题，该值可以存储在任何可变对象中，调用方法和线程都可以引用。您可以使用external this，但除了琐碎的示例以外，它不会特别有用。

关于问题代码的一点说明：扩展Thread通常是较差的样式。实际上，不必要地扩展类是一个坏主意。我注意到您的run方法由于某种原因而被同步。现在，既然是这种情况下的对象，那么Thread您可能会干扰Thread使用其锁的任何对象（在参考实现中，与joinIIRC有关）。

从Java 8开始，我们有了CompletableFuture。根据您的情况，可以使用方法supplyAsync在执行后获取结果。

请找到一些参考。在这里https://www.baeldung.com/java-completablefuture#Processing

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

   completableFuture.get() //gives you the value

使用上面的答案中描述的Future可以完成任务，但不如f.get（）那样阻塞线程，直到获得结果为止，这违反了并发性。

最好的解决方案是使用番石榴的ListenableFuture。一个例子 ：

    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)
        {

        }
    };

只需对代码进行少量修改，即可以更通用的方式实现它。

 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();

解决方案：

1. Handler在UI线程中创建一个称为responseHandler
2. Handler从LooperUI Thread 初始化它。
3. 在中HandlerThread，在此发布消息responseHandler
4. handleMessgae显示Toast从消息中收到的with值。该Message对象是通用的，您可以发送不同类型的属性。

使用这种方法，您可以在不同时间点将多个值发送到UI线程。您可以在其上运行（发布）许多Runnable对象，HandlerThread并且每个对象都Runnable可以在Message对象中设置值，UI线程可以接收该值。