java 线程方法join底层剖析

• 简单说一下：我在网上查找了很多资料，发现资料都有一个共同点，就是只讲清楚了一部分，让人看完之后，一半明白，一半糊涂，很是难受，所以我就以此记录一下，大佬莫怪，嘻嘻。。。
• 直接上代码（跑个程序先！）

/**
 * @Date 2019/7/19 13:02
 **/
public class ThreadDemo {

    public static void main(String[] args) {
        //创建A线程
        Thread a = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName()+";i="+i);
                }
            }
        },"A");
        a.start();
        //创建A线程
        Thread b = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName()+";i="+i);
                }
            }
        },"B");
        b.start();
    }
}

• 输出结果(可想而知啦。。。)，正常交替执行

A;i=0
A;i=1
B;i=0
A;i=2
A;i=3
A;i=4
B;i=1
A;i=5
A;i=6
A;i=7
A;i=8
A;i=9
B;i=2
B;i=3
B;i=4
B;i=5
B;i=6
B;i=7
B;i=8
B;i=9

• 开始进入正题！(需求：先运行A线程，再执行B线程)，上代码

===========第一种代码方式============
/**
 * @Date 2019/7/19 13:02
 **/
public class ThreadDemo {

    public static void main(String[] args) throws InterruptedException {

        //创建A线程
        Thread a = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println(Thread.currentThread().getName()+";i="+i);
                }
            }
        },"A");
        a.start();
        /**
        	注意，join()方法必须在线程启动之后才会生效
        下面开始分析：
        	1.线程A启动开始运转，此时B线程还没有开始，主线程执行到A线程的join方法，此时锁还在主线程手里，主线程拿着锁进入了
        	  A线程的join方法，注意：是主线程拿着锁，并不是A线程，也不是B线程，此时B线程还没有启动，然而A线程依然在执行
        	2.进入join方法的三种线程状态：
        	   主：哈哈，锁在我手，天下我有；手里拿着锁；
        		A：我玩我的，你们继续；继续执行；可以从debug看，此时A线程依然在执行；
        		B：我什们时候才能出生啊；未产生对象
        	3.我们通过join方法的源码(下面贴出代码)可以看出，底层执行了wait()方法，注意：此时锁在主线程手里，
        	4.总结：因为主线程持有锁，主线程进入join方法，执行了wait(),主线程进入等待，A线程没有受到影响继续执行，B线程未创建
        */
        a.join();
       
        //创建A线程
        Thread b = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println(Thread.currentThread().getName()+";i="+i);
                }
            }
        },"B");
        b.start();
    }
}

===========第二种代码方式============
/**
 * @Date 2019/7/19 13:02
 **/
public class ThreadDemo {

    public static void main(String[] args){
        //创建A线程
        final Thread a = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println(Thread.currentThread().getName()+";i="+i);
                }
            }
        },"A");
        a.start();
        //创建A线程
        Thread b = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 100; i++) {
                    try {
                     /**
				        下面开始分析：
				        	1.线程A启动开始运转，线程B启动开始运转，当线程B抢到锁资源的时候，进入本run方法执行join();
				        	2.进入join方法的三种线程状态：
				        	   主：锁没抢到。。。
				        		A：我也没有抢到。。。
				        		B：哈哈，抢到了，好嗨哦。。。都起开，我来；
				        	3.此时B拿着锁进入了join方法,并执行了wait()，B进入等待
        			*/
                        a.join();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+";i="+i);
                }
            }
        },"B");
        b.start();
    }
}

==============join()源代码=============
    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");
        }

        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

总结：问题的关键就是让谁拿到锁，并等待其他线程执行完毕，然后唤醒自己。