最近在编程遇到了个需要异步执行的操作,经过了一番折腾,发现在主子线程操作中join()方法是非常实用且有效的一个方法.
先来看join()及其重载(overload)方法的说明和代码:
join()方法:
1 /**
2 * Waits for this thread to die.
3 *
4 * @exception InterruptedException if another thread has interrupted
5 * the current thread. The <i>interrupted status</i> of the
6 * current thread is cleared when this exception is thrown.
7 */
8 public final void join() throws InterruptedException {
9 join(0);
10 }
join(long millis)方法:
1 /**
2 * Waits at most <code>millis</code> milliseconds for this thread to
3 * die. A timeout of <code>0</code> means to wait forever.
4 *
5 * @param millis the time to wait in milliseconds.
6 * @exception InterruptedException if another thread has interrupted
7 * the current thread. The <i>interrupted status</i> of the
8 * current thread is cleared when this exception is thrown.
9 */
10 public final synchronized void join(long millis) throws InterruptedException {
11
12 long base = System.currentTimeMillis();
13 long now = 0;
14
15 if (millis < 0) {
16 throw new IllegalArgumentException("timeout value is negative");
17 }
18
19 if (millis == 0) {
20 while (isAlive()) {
21 wait(0);
22 }
23 } else {
24 while (isAlive()) {
25 long delay = millis - now;
26 if (delay <= 0) {
27 break;
28 }
29 wait(delay);
30 now = System.currentTimeMillis() - base;
31 }
32 }
33 }
join(long millis, int nanos)方法:
1 /**
2 * Waits at most <code>millis</code> milliseconds plus
3 * <code>nanos</code> nanoseconds for this thread to die.
4 *
5 * @param millis the time to wait in milliseconds.
6 * @param nanos 0-999999 additional nanoseconds to wait.
7 * @exception IllegalArgumentException if the value of millis is negative
8 * the value of nanos is not in the range 0-999999.
9 * @exception InterruptedException if another thread has interrupted
10 * the current thread. The <i>interrupted status</i> of the
11 * current thread is cleared when this exception is thrown.
12 */
13 public final synchronized void join(long millis, int nanos) throws InterruptedException {
15
16 if (millis < 0) {
17 throw new IllegalArgumentException("timeout value is negative");
18 }
19
20 if (nanos < 0 || nanos > 999999) {
21 throw new IllegalArgumentException("nanosecond timeout value out of range");
23 }
24
25 if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
26 millis++;
27 }
28
29 join(millis);
30 }
31
在使用中需要注意的地方有:
1. join()方法定义在Thread类中,所以只有线程可以直接调用它.
2. join()方法会有可能抛出InterruptedException,需要用try/catch语句块包围;
3. join()方法的作用是"Waits for this thread to die",所以你要start()该线程先.
下面再看一个使用join()方法的实例:
1 import java.io.*;
2
3 public class JoinDemo {
4
5 public static void main(String[] args){
6
7 ThreadMain main = new ThreadMain();
8 //启动主线程
9 main.start();
10
11 }
12 }
13
14 //主线程类
15 class ThreadMain extends Thread{
16
17 ThreadSub sub = new ThreadSub();
18
19 public void run(){
20
21 System.out.println("ThreadMain starts!");
22 //启动子线程
23 sub.start();
24
25 System.out.println("ThreadMain running before threadsub!");
26
27 try{
28 sub.join();
29 }catch(InterruptedException e){
30 e.printStackTrace();
31 }
32
33 System.out.println("ThreadMain running after threadsub!");
34
35 System.out.println("ThreadMain ends!");
36 }
37 }
38
39 //子线程类
40 class ThreadSub extends Thread{
41
42 public void run(){
43
44 System.out.println("ThreadSub starts!");
45
46 for(int i = 0; i < 10; i++){
47 System.out.println("ThreadSub running: " + (i+1));
48 }
49
50 System.out.println("ThreadSub ends!");
51 }
52 }
输出结果为:
ThreadMain starts!
ThreadMain running before threadsub!
ThreadSub starts!
ThreadSub running: 1
ThreadSub running: 2
ThreadSub running: 3
ThreadSub running: 4
ThreadSub running: 5
ThreadSub running: 6
ThreadSub running: 7
ThreadSub running: 8
ThreadSub running: 9
ThreadSub running: 10
ThreadSub ends!
ThreadMain running after threadsub!
ThreadMain ends!
通过这个例子可以更好地理解"Waits for this thread to die"的含义.