如何处理线程返回的值

最新推荐文章于 2025-05-21 17:59:26 发布

转载最新推荐文章于 2025-05-21 17:59:26 发布 · 196 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：https://blog.youkuaiyun.com/Pastthewind/article/details/101000305

文章标签：

#thread

thread 专栏收录该内容

5 篇文章

订阅专栏

本文详细介绍四种在Java中从多线程获取数据的方法：主线程等待法、使用Thread的join阻塞、通过Callable的FutureTask以及使用线程池的Future实现。每种方法都附带了详细的代码示例，帮助读者深入理解并掌握多线程编程中的数据同步技巧。

（1）主线程等待法

package com.interview.thread;

//获取多线程返回值1：主线程等待
public class CycleWait implements Runnable{
   private String value;

   @Override
   public void run() {
       try {
           Thread.sleep(5000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       this.value = "we have data now";
   }
   public static void main(String[] args) throws InterruptedException {
       CycleWait cw = new CycleWait();
       Thread t1 = new Thread(cw);
       t1.start();
       while(cw.value == null) {
               Thread.sleep(100);
       }
       System.out.println("value：" + cw.value);
   }

}
（2）使用Thread的join阻塞当前线程等待

package com.interview.thread;

//获取多线程返回值1：主线程等待
public class CycleWait implements Runnable{
   private String value;

   @Override
   public void run() {
       try {
           Thread.sleep(5000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       this.value = "we have data now";
   }
   public static void main(String[] args) throws InterruptedException {
       CycleWait cw = new CycleWait();
       Thread t1 = new Thread(cw);
       t1.start();
       t1.join();
       System.out.println("value：" + cw.value);
   }

}
（3）通过Callable的FutureTask

package com.interview.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class FutureTaskDemo {
   public static void main(String[] args) throws InterruptedException, ExecutionException {
       FutureTask<String> task = new FutureTask<>(new MyCallable());
       new Thread(task).start();
       if(!task.isDone()) {
           System.out.println("任务未处理完成。。");
       }
       System.out.println("任务执行结果：" + task.get());
   }
}
class MyCallable implements Callable<String>{

   @Override
   public String call() throws Exception {

       String value = "result value";
       System.out.println("线程开始处理任务");
       Thread.sleep(5000);
       System.out.println("线程结束处理任务");
       return value;
   }

}
（4）通过Callable接口，线程池的Future实现

package com.interview.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class FutureTaskDemo {
   public static void main(String[] args) throws Exception {
       ExecutorService pool = Executors.newCachedThreadPool();
       Future<String> future = pool.submit(new MyCallable());
       if(!future.isDone()) {
           System.out.println("等待任务...");
       }
       System.out.println("结果：" + future.get());
       pool.shutdown();
   }
}

class MyCallable implements Callable<String>{

   @Override
   public String call() throws Exception {

       String value = "result value";
       System.out.println("线程开始处理任务");
       Thread.sleep(5000);
       System.out.println("线程结束处理任务");
       return value;
   }

}

————————————————
版权声明：本文为优快云博主「Pastthewind」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.youkuaiyun.com/Pastthewind/article/details/101000305