首先我们来看看下面的代码和其运行结果：

public class MyStack1 {
    public static volatile int i = 0;
    public static class JoinTest extends Thread {
        @Override
        public void run() {
            for (;i < 100; i++ );
        }
    }

    public static void main(String args[]) throws InterruptedException {
        JoinTest joinTest = new JoinTest();
        joinTest.start();
        System.out.println(i);
    }
}

0

首先我们得认识到start()只是让线程进入就绪状态，并未执行。

结果不是100这不意外，因为main线程先于joinTest线程执行完毕，甚至说joinTest线程还处于就绪状态时main线程就已经输出i的值了。
接下来我们看加了joinTest.join();的情况：

public class MyStack1 {
    public static volatile int i = 0;
    public static class JoinTest extends Thread {
        @Override
        public void run() {
            for (;i < 100; i++ );
        }
    }

    public static void main(String args[]) throws InterruptedException {
        JoinTest joinTest = new JoinTest();
        joinTest.start();
        joinTest.join();
        System.out.println(i);
    }
}

100

没错，main线程在"joinTest.join();"这里便等待joinTest线程的结束。

我们来看看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;
            }
        }
    }

这是一个同步非静态方法，当main线程调用了joinTest.join()时获取到了当前实例（joinTest）的锁，并调用了wait方法，此时main线程便会释放锁对象并进入等待队列中,当joinTest线程执行结束时或者millis时间到时才会唤醒main线程。说到底还是线程之间的wait和notify的作用关系。

这里顺带介绍下线程的让步：

public static native void yield();

此方法是静态方法，调用者会让出cpu时间，但调用者依旧会进行cpu资源的抢夺。

该方法适用于某些不重要但又怕它过多占用cpu时间的线程。