一、主线程等待法:优点:实现简单,缺点:代码冗余
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();
}
}
}