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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
/**
     * Waits at most {@code millis} milliseconds for this thread to
     * die. A timeout of {@code 0} means to wait forever.
     *
     * <p> This implementation uses a loop of {@code this.wait} calls
     * conditioned on {@code this.isAlive}. As a thread terminates the
     * {@code this.notifyAll} method is invoked. It is recommended that
     * applications not use {@code wait}, {@code notify}, or
     * {@code notifyAll} on {@code Thread} instances.
     *
     * @param  millis
     *         the time to wait in milliseconds
     *
     * @throws  IllegalArgumentException
     *          if the value of {@code millis} is negative
     *
     * @throws  InterruptedException
     *          if any thread has interrupted the current thread. The
     *          <i>interrupted status</i> of the current thread is
     *          cleared when this exception is thrown.
     */
    public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        // 0则需要一直等到目标线程run完
        if (millis == 0) {
            while (isAlive()) {// 如果被调用join方法的线程是alive状态，则调用join的方法
                wait(0); // == this.wait(0),注意这里释放的是「被调用」join方法的线程对象的锁
            }
        } else {
            // 如果目标线程未run完且阻塞时间未到，那么调用线程会一直等待。
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                /**
                * 每次最多等待delay毫秒时间后继续争抢对象锁，获取锁后继续从这里开始的下一行执行，也可能提前被notify()
                * /notifyAll()唤醒，造成delay未一次性消耗完，会继续执行while继续wait(剩下的delay)
                */
                wait(delay);
                now = System.currentTimeMillis() - base; // 这个变量now起的不太好，叫elapsedMillis就容易理解了
            }
        }
    }

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
package com.java.test;

/**
 * 模拟Thread.join()在有锁情况下是否释放锁的例子
 */
public class HelloJava {

    public static void main(String[] args) {
        String oo = new String();
        MyThread t1 = new MyThread("线程t1--", oo, null);
        MyThread t2 = new MyThread("线程t2--", oo, t1);
        t2.start(); // 注意是t2先启动
        t1.start(); // 注意t1一定要处于启动状态，否则t1.join()方法会直接返回
        try {
            t1.join(); // 等待t1结束后main才会继续执行，进入t1的wait set，t1执行完毕后会主动唤醒它
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("end");
    }

}

class MyThread extends Thread{
    private String name;
    private Object oo;
    private Thread t;
    public MyThread(String name,Object oo, Thread t){
        super(name);
        this.name = name;
        this.t = t;
        this.oo = oo;
    }
    @Override
    public void run() {
        synchronized (oo) {
            System.out.println("running in " + Thread.currentThread().getName());
            if (t != null) {
                try {
                    t.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            for(int i = 0; i < 10; i++){
                System.out.println(name + i);
            }
        }
    }
}

Output：
running in 线程t2--
(hanging)

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
class A extends Thread {
   static A a;
  
   public void run() {
      try {
         synchronized(a) {
            System.out.println(Thread.currentThread().getName()+" acquired a lock on a");
            Thread.sleep(1000);
         }
      } catch (InterruptedException e){
      }
   }
  
   public static void main(String[] ar) throws Exception {
      a=new A();
      a.start();
      synchronized(a) {
         System.out.println(Thread.currentThread().getName()+" acquired a lock on a");
         a.join();
         System.out.println(Thread.holdsLock(a));
      }
   }
}
  
Output:
  
main acquired a lock on a
Thread-1 acquired a lock on a
true