Thread -- 03 -- 实现处理线程的返回值

原文链接：Thread – 03 – 实现处理线程的返回值

---

相关文章：

• Thread – 01 – 进程和线程的区别

• Thread – 02 – 线程的六种状态

• Thread – 03 – 实现处理线程的返回值

• Thread – 04 – Thread和Runnable的区别

• Thread – 05 – start()与run()的区别

• Thread – 06 – sleep()和wait()的区别

• Thread – 07 – notify()和notifyAll()的区别

• Thread – 08 – yieled()方法的使用

• Thread – 09 – interrupt()方法的使用

• Thread – 10 – interrupt()、interrupted()、isInterrupted()方法的区别

---

在日常开发过程中，有的程序的执行是依赖于子任务的返回值进行的，当子任务交给子线程去完成的时候，我们需要获取到子线程执行完毕后的返回值，现在让我们来看看如何实现处理线程的返回值

实现的方式主要有三种

• 主线程等待法

• 使用 Thread 类的 join() 方法阻塞当前线程以等待子线程处理完毕

• 实现 Callable 接口，通过 Future 或 FutureTask 来获取

---

一、主线程等待法

public class CycleWait implements Runnable {

    private String value;

    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        value = "we have data now";
    }

    public static void main(String[] args) throws InterruptedException {
        CycleWait cw = new CycleWait();
        Thread t = new Thread(cw);
        t.start();
        while (null == cw.value) {
            Thread.sleep(100);
        }
        System.out.println("value: " + cw.value); // value: we have data now
    }
}

---

二、使用 Thread 类的 join() 方法阻塞当前线程以等待子线程处理完毕

public class CycleWait implements Runnable {

    private String value;

    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        value = "we have data now";
    }

    public static void main(String[] args) throws InterruptedException {
        CycleWait cw = new CycleWait();
        Thread t = new Thread(cw);
        t.start();
        t.join();
        System.out.println("value: " + cw.value); // value: we have data now
    }
}

---

三、实现 Callable 接口，通过 Future 或 FutureTask 来获取

public class MyCallable implements Callable<String> {

    @Override
    public String call() throws Exception {
        String value = "test";
        System.out.println("Ready to work");
        Thread.sleep(1000);
        System.out.println("task done");
        return value;
    }
}

• 通过 Future 来获取

  public class FutureDemo {
  
      public static void main(String[] args) {
          ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
          Future<String> future = newCachedThreadPool.submit(new MyCallable());
          if (!future.isDone()) {
              System.out.println("task has not finished, please wait!");
          }
          try {
              System.out.println("task return: " + future.get());
              
              // task has not finished, please wait!
              // Ready to work
              // task done
              // task return: test
          } catch (Exception e) {
              e.printStackTrace();
          } finally {
              newCachedThreadPool.shutdown();
          }
      }
  }
  

  • 如上所示，使用 Executors 类的 newCachedThreadPool() 方法来构造了一个线程池

  • submit()

    • 用于向线程池提交任务，可以接收 Callable 参数

  • isDone()

    • 用于判断 Callable 实现类的 call() 方法是否执行完毕

• 通过 FutureTask 来获取

  public class FutureTaskDemo {
  
      public static void main(String[] args) throws ExecutionException, InterruptedException {
          FutureTask<String> task = new FutureTask<>(new MyCallable());
          new Thread(task).start();
          if (!task.isDone()) {
              System.out.println("task has not finished, please wait!");
          } 
          System.out.println("task return: " + task.get());
          
          // task has not finished, please wait!
          // Ready to work
          // task done
          // task return: test
      }
  }
  

  • 如上所示，FutureTask 的构造函数可以接收 Callable 参数

  • isDone()

    • 用于判断 Callable 实现类的 call() 方法是否执行完毕

  • get()

    • 用于阻塞当前调用它的线程，直到 Callable 实现类的 call() 方法执行完毕，取到返回值