如何实现处理线程的返回值

Dear 丶 2021-10-18 05:50 286阅读 0赞

1、主线程等待法

实现起来比较简单，缺点是需要自己实现循环等待的逻辑，当需要等待的变量一多，代码便会显得异常的臃肿，无法做到精准的控制。

public class MyRunnable implements Runnable {
    
        private String name;
    
        @Override
        public void run() {
            try {
                Thread.currentThread().sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            name = "ha ha";
            System.out.println(Thread.currentThread().getName()+name);
        }
    
        public static void main(String[] args) throws InterruptedException {
            MyRunnable myRunnable = new MyRunnable();
            Thread thread = new Thread(myRunnable);
            thread.start();
            while(myRunnable.name == null) {
                Thread.currentThread().sleep(1000);
            }
            System.out.println(myRunnable.name);
        }
    }

2、使用Thread类的join()阻塞当前线程以等待子线程处理完毕，缺点是控制力度不够细。

public class MyRunnable implements Runnable {
    
        private String name;
    
        @Override
        public void run() {
            try {
                Thread.currentThread().sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            name = "ha ha";
            System.out.println(Thread.currentThread().getName()+name);
        }
    
        public static void main(String[] args) throws InterruptedException {
            MyRunnable myRunnable = new MyRunnable();
            Thread thread = new Thread(myRunnable);
            thread.start();
            thread.join();
            System.out.println(myRunnable.name);
        }
    }

/**
 * Waits for this thread to die.
 *
 * An invocation of this method behaves in exactly the same
 * way as the invocation
 *
 * <blockquote>
 * {@linkplain #join(long) join}{@code (0)}
 * </blockquote>
 *
 * @throws InterruptedException
 * if any thread has interrupted the current thread. The
 * interrupted status of the current thread is
 * cleared when this exception is thrown.
 */
 public final void join() throws InterruptedException {
 join(0);
 }

3、通过Callable接口实现：通过FutureTask Or 线程池获取

Callable接口源码如下，只有一个方法

/*
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */
 
 /*
 *
 *
 *
 *
 *
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 */
 
 package java.util.concurrent;
 
 /**
 * A task that returns a result and may throw an exception.
 * Implementors define a single method with no arguments called
 * {@code call}.
 *
 * The {@code Callable} interface is similar to {@link
 * java.lang.Runnable}, in that both are designed for classes whose
 * instances are potentially executed by another thread. A
 * {@code Runnable}, however, does not return a result and cannot
 * throw a checked exception.
 *
 * The {@link Executors} class contains utility methods to
 * convert from other common forms to {@code Callable} classes.
 *
 * @see Executor
 * @since 1.5
 * @author Doug Lea
 * @param <V> the result type of method {@code call}
 */
 @FunctionalInterface
 public interface Callable<V> {
 /**
 * Computes a result, or throws an exception if unable to do so.
 *
 * @return computed result
 * @throws Exception if unable to compute a result
 */
 V call() throws Exception;
 }

1）FutureTask实现

import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.FutureTask;
 
 public class MyCallable implements Callable<String> {
 
 @Override
 public String call() throws InterruptedException {
 System.out.println("Waiting...");
 Thread.currentThread().sleep(2000);
 System.out.println("Start...");
 return "myCallable";
 }
 
 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");
 }
 System.out.println("Task return: " + task.get());
 }
 }

2）、线程池获取

import java.util.concurrent.*;
 
 public class MyCallable implements Callable<String> {
 
 @Override
 public String call() throws InterruptedException {
 System.out.println("Waiting...");
 Thread.currentThread().sleep(2000);
 System.out.println("Start...");
 return "myCallable";
 }
 
 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");
 }
 try {
 System.out.println("Task return: " + future.get());
 } catch (InterruptedException e) {
 e.printStackTrace();
 } catch (ExecutionException e) {
 e.printStackTrace();
 } finally {
 newCachedThreadPool.shutdown();
 }
 }
 }