Java多線程-處理線程的返回值

一、主線程等待法：優點：實現簡單，缺點：代碼冗余

package com.test.thread;

public class CycleWait implements Runnable {
    private String value;

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

    public static void main(String[] args) throws InterruptedException {
        CycleWait cycleWait = new CycleWait();
        Thread t = new Thread(cycleWait);
        t.start();
        while (cycleWait.value == null) {
            Thread.sleep(100);
        }
        System.out.println(cycleWait.value);
    }
}

運行結果:

we have data now

二、使用Thread類的join()阻塞當前線程，以等待子線程處理完畢。優點：比“主線程等待法”更簡單 缺點：粒度不夠細

package com.test.thread;

public class CycleWait implements Runnable {
    private String value;

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

    public static void main(String[] args) throws InterruptedException {
        CycleWait cycleWait = new CycleWait();
        Thread t = new Thread(cycleWait);
        t.start();
       // join方法，在start后
        t.join();
        System.out.println(cycleWait.value);
    }
}
    

三、通過Callable接口實現：通過FutureTask 或者 線程池獲取

 1、future task

MyCallable.class：

package com.test.thread;

import java.util.concurrent.Callable;
// 實現callable接口
public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        String value = "test";
        System.out.println("ready to work");
        Thread.sleep(5000);
        System.out.println("task done");
        return value;
    }
}

FutureTaskDemo.class:
package com.test.thread;

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

//future task
public class FutureTaskDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> task = new FutureTask<String>(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());
    }
}

2、線程池

TreadPoolDemo.class:
package com.test.thread;

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

public class TreadPoolDemo {
    public static void main(String[] args) {
        // 創建線程池
        ExecutorService executorService =
                Executors.newCachedThreadPool();
        // 向線程池中提交任務
        Future<String> future = executorService.submit(new MyCallable());
        // 判斷任務是否完成
        if (!future.isDone()) {
            System.out.println("task not finished, please wait~~");
        }
        try {
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } finally {
            // 將線程池關閉
            executorService.shutdown();
        }
    }
}