处理实现线程获取值

方式一：主线程等待法

如果未获取到值，则主线程等待，一直到获取值为止。

    package mrzhangxd.xyz.thread;
    
    /**
     * CopyRight (C),2019
     *
     * @ClassName: ThreadWait
     * @Auther: zhangxiaodong3
     * @Created: 2019/12/2015:11
     * @Description: 处理实现线程获取值
     */
    
    /**
      * 如果未获取到值，则主线程等待，一直到获取值为止。
      */
    public class ThreadWait implements Runnable{
    
        private String value;
    
        public static void main(String[] args){
    
            ThreadWait tw = new ThreadWait();
            Thread t = new Thread(tw);
            t.start();
    
            //TODO:如果未获取到值，则主线程等待，一直获取到值为止
            while (tw.value == null){
    
                try {
                    //主线程等待法
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    
            System.out.println("Value:"+tw.value);
            //输出结果：Value:My name is MrZhangxd!!!
        }
        @Override
        public void run() {
    
    
            try {
    
                Thread.sleep(5000);
    
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            value = "My name is MrZhangxd!!!";
    
        }
    }

方式二：join()

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

package mrzhangxd.xyz.thread;

/**
* CopyRight (C),2019
*
* @ClassName: ThreadWaitJoin
* @Auther: zhangxiaodong3
* @Created: 2019/12/2015:26
* @Description: 处理实现线程获取值
*/

//使用 Thread 的 join() 阻塞当前线程以等待子线程处理完毕。

public class ThreadWaitJoin implements Runnable {

private String value;

public static void main(String[] args) throws InterruptedException {

ThreadWaitJoin twj = new ThreadWaitJoin();
Thread t = new Thread(twj);
t.start();

//TODO：使用 Thread 的 join 方法阻塞当前线程，等待子线程执行完毕
t.join();//阻塞当前主线程，直到 t 线程执行完毕
System.out.println("Value:" + twj.value);

//输出结果：
//Value:My name is MrZhangxd!!!
}

@Override
public void run() {

try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}

value = "My name is MrZhangxd!!!";

}
}

方式三：Callable + FutureTask

实现 Callablee 接口，使用 FutureTask 接收 call() 方法返回的数据。

package mrzhangxd.xyz.thread;

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

/**
* CopyRight (C),2019
*
* @ClassName: ThreadWaitFutureTask
* @Auther: zhangxiaodong3
* @Created: 2019/12/2015:45
* @Description: 处理实现线程获取值
*/

//实现 Callablee 接口，使用 FutureTask 接收 call() 方法返回的数据。
public class ThreadWaitFutureTask implements Callable {

private String value;

public static void main(String[] args)throws InterruptedException, ExecutionException{

ThreadWaitFutureTask twft = new ThreadWaitFutureTask();

FutureTask ft = new FutureTask(twft);

Thread t = new Thread(ft);

t.start();

while (!ft.isDone()){
// FutureTask 的 get() 方法会一直阻塞，一直会等待任务执行完毕，才返回。
Thread.sleep(1000);

}

System.out.println("Vaule:"+ft.get());

//输出结果：
//Vaule:My name is MrZhangxd!!!

}
@Override
public String call() throws Exception {

Thread.sleep(5000);
value = "My name is MrZhangxd!!!";
return value;
}

}

方式四：线程池 + Future

线程池执行任务，返回的结果使用 Future 接收。

package mrzhangxd.xyz.thread;

import java.util.concurrent.*;

/**
* CopyRight (C),2019
*
* @ClassName: ThreadWaitFuture
* @Auther: zhangxiaodong3
* @Created: 2019/12/20 15:58
* @Description: 处理实现线程获取值
*/

//线程池执行任务，返回的结果使用 Future 接收。

public class ThreadWaitFuture implements Callable {

private String vaule;

public static void main(String[] args) throws InterruptedException, ExecutionException {

ExecutorService service = Executors.newCachedThreadPool();
ThreadWaitFuture twf = new ThreadWaitFuture();
//将任务提交给线程池处理
Future future = service.submit(twf);

while (!future.isDone()){

Thread.sleep(1000);

}

System.out.println("Value:"+future.get());
//关闭线程池
service.shutdown();

//运行结果：
//Vaule:My name is MrZhangxd!!!

}

@Override
public String call() throws Exception {

Thread.sleep(5000);
vaule = "My name is MrZhangxd！！！";
return vaule;
}
}