一、主线程等待法：优点：实现简单，缺点：代码冗余
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
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);
}
}
|
运行结果:
|
1
|
we have data now
|
二、使用Thread类的join()阻塞当前线程，以等待子线程处理完毕。优点：比“主线程等待法”更简单 缺点：粒度不够细
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
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
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
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;
}
}
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
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、线程池
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
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();
}
}
}
|