Thread 处理线程返回值

方法一： 主线程等待法 缺点，等待时间不精准，以设定的等待时间为一个单位，如果返回的变量比较多，则while条件繁琐。

方法二： 使用Thread类的join()阻塞当前线程以等待当前线程处理完毕。缺点：处理细读不够。

方法三： 使用Callable接口实现; 通过FutureTask Or 线程池Executors.newCachedThreadPool()获取。使用线程池优势：可以提交多个实现callable方法的类，让线程池并发的处理结果。方便线程池对这些callable方法的类做统一的管理。

 

package com.mall.controllor.alene;

/**
 * Created by 60341 on 2020/3/17.
 */
public class CycleWait implements Runnable{
    private String value;
    @Override
    public void run() {
        try {
            Thread.currentThread().sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        value = " have data now! ";
    }

    public static void main(String[] args) throws InterruptedException {
        CycleWait cycleWait = new CycleWait();
        Thread t = new Thread(cycleWait);
        t.start();
        //方法一;主线程等待法 缺点，等待时间不精准，以设定的等待时间为一个单位，如果返回的变量比较多，则while条件繁琐。
        while(cycleWait.value ==null){
            Thread.currentThread().sleep(100);
        }
        //使用Thread类的join()阻塞当前线程以等待当前线程处理完毕。缺点：处理细读不够，
        t.join();
        //使用Callable接口实现;通过FutureTask Or 线程池获取

        System.out.println(cycleWait.value);
    }
}

package com.mall.controllor.alene;

import java.util.concurrent.Callable;

/**
 * Created by 60341 on 2020/3/18.
 */
public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        String value = "test";
        System.out.println("Ready to work ");
        Thread.currentThread().sleep(5000);
        System.out.println(" task is done ");
        return value;
    }
}

package com.mall.controllor.alene;

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

/**
 * Created by 60341 on 2020/3/18.
 */
public class FutureTaskDemo {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //FutureTask<String> ，实现了RunnableFuture接口，该接口继承了Runnable，所以可以理用Thread实现多线程；
        // FutureTask<String>构造函数中，可以接受Callable的实现实例。
        // FutureTask<String>中String为ew MyCallable()的call方法返回值类型；
        FutureTask<String> futureTask  = new FutureTask<String>(new MyCallable());
        //开启线程，Thread可以接受runnable实现。
        new Thread(futureTask).start();
        //futureTask.isDone()表示Callable的实现实例的call方法已经执行完毕，并返回数据。
        if(!futureTask.isDone()){
            System.out.println("task has not finished,please wait");
        }
        //futureTask.get() 得到Callable的实现实例的call方法返回的数据后才进行下一步处理。
        // futureTask.get(long timeout, TimeUnit unit)是返回超时抛异常
        System.out.println("task return: " + futureTask.get() );
    }
}

package com.mall.controllor.alene;

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

/**
 * Created by 60341 on 2020/3/18.
 */
public class ThreadPoolDemo {
    //使用线程池优势：可以提交多个实现callable方法的类，让线程池并发的处理结果。方便线程池对这些callable方法的类做统一的管理。
    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(future.get());xia
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } finally {
            //关闭线程池
            newCachedThreadPool.isShutdown();
        }
    }
}