如何给run()方法传参

我们都知道,跟线程相关的业务逻辑都是要放在run()方法里去执行的,而run()方法是没有参数也没有返回值的,那么应该如何给run()方法传参呢?

1. 构造函数传参: 这就是我上一篇博客里利用Runnable接口实现多线程的例子.
2. 成员变量传参: 这个就比如我在run()方法里使用了一个全局变量,我们通过给全局变量赋值然后在run方法中使用该值,就起到了传参的效果,就是我上一篇博客Thread实现多线程的例子.
3. 回调函数传参: 我jio的就是在run()方法里去调用其他方法并获取其返回值加以使用的意思.

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

我们有的程序的执行依赖于子任务的返回值进行的,当子任务通过线程去执行的时候,是需要获取其返回值的,这可咋整?实现子线程返回值的方法是啥?

1. 主线程等待法,即我们可以让主线程循环等待,直到目标子线程返回了其结果为止,这种方法实现起来比较简单,但是需要自己实现循环等待的逻辑,以及我们不知道要等待多久,需要等待的变量一多,代码就会很臃肿.

public class MainThreadWait implements Runnable{

    private String value;

    @Override
    public void run() {
        try {
            Thread.currentThread().sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("running");
        value = "we have data now";
    }

    public static void main(String[] args) throws InterruptedException {
        MainThreadWait mtw = new MainThreadWait();
        Thread t1 = new Thread(mtw);

        t1.start();
        //直接执行main方法,还是会出现value为空的现象,因为主线程没有等它赋值结束就执行了打印语句,此时我们就需要让主线程一直等着
        while (mtw.value == null) {
            System.out.println("waiting...");
            Thread.currentThread().sleep(100);
        }
        //有了上面的代码之后,我们会发现,主线程会等待500毫秒直到value有值之后才会执行这条语句
        System.out.println(mtw.value);
    }
}

2. 利用Thread类的join()方法来阻塞当前线程以等待子线程处理完毕.
   其中,join()的作用就是无限期阻塞当前线程,等待调用join()方法的线程对象被销毁再执行其他线程

public class MainThreadWait implements Runnable{

    private String value;

    @Override
    public void run() {
        try {
            Thread.currentThread().sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("running");
        value = "we have data now";
    }

    public static void main(String[] args) throws InterruptedException {
        MainThreadWait mtw = new MainThreadWait();
        Thread t1 = new Thread(mtw);

        t1.start();
        //阻塞当前线程等待t1线程执行结束
        t1.join();
        //有了上面的代码之后,我们会发现,主线程会等待500毫秒直到value有值之后才会执行这条语句
        System.out.println(mtw.value);
    }
}

3. 通过Callable接口实现:通过FutureTask这个类或者线程池获取返回值

实现了Callable接口的任务可以有返回值,并且可以抛出异常,run()方法都不可以.
在执行Callable任务之后,可以获取一个Future接口对象,然后通过get方法就可以获取Callable任务返回的Object对象了.
通过Callable方式获取线程的返回值主要有两种方式: 通过FutureTask这个Future接口的实现类或者线程池获取.

---创建MyCallable类
public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        String value = "test";
        System.out.println("ready to work");
        //让当前线程休眠1秒
        Thread.currentThread().sleep(1000);
        System.out.println("task done");
        return value;
    }
}

---FutureTask方式测试类
public class MyCallable_FutureTask {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> task = new FutureTask<String>(new MyCallable());
        //因为Future接口继承了Runnable接口,而Thread可以通过Ruannable创建线程,所以这里可以穿task.
        Thread thread = new Thread(task);
        thread.start();

        //如果还没有执行结束
        if (!task.isDone()) {
            System.out.println("task has not finished, please wait");
        }
        //5秒之后,才会执行这句话
        System.out.println("task return : " + task.get());
    }
}
输出结果如图:

我们直接利用一下上面的Callable类
public static void main(String[] args) {
        //线程池创建好之后,就往线程池提交任务去让它执行,此处的任务就是我们的Callable
        ExecutorService newCacheThreadPool = Executors.newCachedThreadPool();
        Future<String> future = newCacheThreadPool.submit(new MyCallable());
        if (!future.isDone()) {
            System.out.println("task has not finished, please wait");
        }
        try {
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } finally {
            //关闭线程池
            newCacheThreadPool.shutdown();
        }
    }
    输出结果和上面的一样的.

使用线程池获取结果的好处就是我们可以提交多个实现Callable接口的类去让线程池并发(可以理解为多个线程同时进行) 的处理结果,其他的方法都是线性的,按照代码的顺序执行对应的线程.