从线程返回值

Question

我有一个带有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();
}

Answer 1

通常你会这样做

 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 一个线程不能返回一个值（至少在没有回调机制的情况下不能）。您应该像普通类一样引用线程并请求值。

Answer 2

您正在寻找的可能是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();
}

Answer 3

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

您也可以像这样使用Executor 和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();
}

Answer 4

如果你想要调用方法的值，那么它应该等待线程完成，这使得使用线程有点毫无意义。

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

关于问题中的代码的一点说明：扩展Thread 通常是糟糕的风格。确实，不必要地扩展类是一个坏主意。我注意到你 run 方法由于某种原因是同步的。现在，由于本例中的对象是Thread，您可能会干扰Thread 使用其锁定的任何内容（在参考实现中，与join，IIRC 有关）。

Answer 5

这个解决方案怎么样？

它不使用 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()，那么调用它的线程只会等到它完成

Answer 6

使用上述答案中描述的 Future 可以完成这项工作，但不如 f.get() 显着，它会阻塞线程直到它得到结果，这违反了并发性。

最好的解决方案是使用 Guava 的 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)
        {

        }
    };

Answer 7

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

 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. 在UI Thread中创建一个Handler，称为responseHandler
2. 从 UI 线程的 Looper 初始化这个 Handler。
3. 在HandlerThread，在此responseHandler 上发布消息
4. handleMessgae 显示了一个 Toast ，其中包含从消息中接收到的值。此 Message 对象是通用的，您可以发送不同类型的属性。

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

Answer 8

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

请参考here。

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

   completableFuture.get() //gives you the value

Answer 9

这是一种更简洁的方法，您只需对现有代码进行一些更改。目标是从线程中获取结果。结果不一定是return。相反，使用回调样式获取该结果并进行进一步处理。

public class Test {

  public static void main(String[] args) {
    String str = args[0];
    int count = 0;

    Thread t = new Thread(() ->
      someFuncToRun(str, count, (value) -> {
        System.out.println(value);
        return value;
      }));

    t.start();
  }
  // Here I even run a recursive method because run things in the 
  // a thread sometime is to delegate those heavy lifting elsewhere
  public static String someFuncToRun(String str, int ctn, Callback<String> p) {
    ++ctn;
    if (ctn == 10) {
      System.out.println("End here");
      return p.cb(str);
    }
    System.out.println(ctn + " times");
    return someFuncToRun(str + " +1", ctn, p);
  }
}

// The key is here, this allow you to pass a lambda callback to your method 
// update: use generic to allow passing different type of data
// you could event make it <T,S> so input one type return another type  
interface Callback<T> {
    public T cb(T a);
}