1. 等待一个线程 join
有一天张三与小美在家里吃饭，张三早早的把饭吃完了，对小美说，等你把饭吃完了，我就去洗碗了！
此时张三就要等待小美吃完饭才能去洗碗，就好比线程 A 要等待线程 B 执行完，线程 A 才能接着往后干活！
等待线程，就是控制两个线程的结束顺序，使用 join 方法。
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(() -> {
System.out.println("小美吃饭中!");
try {
Thread.sleep(10_000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("小美吃完饭了!");
});
t.start();
System.out.println("张三吃完饭了!");
t.join(); // main 线程等待 t 线程执行完毕
System.out.println("张三去洗碗了!");这里当 t.start() 之后，t 和 main 线程就开始并发执行了，当 main 线程执行到 t.join() 表示 main 线程得等 t 线程执行完毕后，才能接着往后执行代码！只要 t 线程没有执行完毕，main 线程就会发生阻塞，一直阻塞到 t 线程执行完毕，也就是执行完对应的 run 方法！
像上述代码是可以等到 t 线程执行完毕了，如果 t 线程执行的任务里面出现了死循环怎么办呢？此时 main 线程是不是也得无休止的等待了？确实是这样的，但是 join 给我们提供了一个带参数的方法，等指定的时间，到点就不等了！
比如小美吃饭的速度特别慢，张三说，我就等你 5 秒钟，5 秒之后你还没吃完，我就自己洗碗了去了！
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(() -> {
System.out.println("小美吃饭中!");
try {
Thread.sleep(10_000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("小美吃完饭了!");
});
t.start();
System.out.println("张三吃完饭了!");
t.join(5000); // 只等待5秒
System.out.println("张三去洗碗了!");
}
此时就能发现，小美没有吃完饭，但是张三还是去洗碗了，为什么呢？
因为 main 线程只等了 t 线程 5秒，但是 t 线程执行的 run 方法，可不止 5秒，里面还 sleep 了10秒钟，相当于小美还需要 10秒 才能吃完饭呢！
由此可见，这次张三肯定不会等小美吃完饭之后才去洗碗，就如同上面的打印结果一般。
此时还有一种情况，会不会小美比张三先吃完饭呢？
有可能！比如 main 线程执行 t.join() 的时候，但是 t 线程的 run 方法已经执行完了，此时 join 就不会阻塞了，就会立即返回！
同时 join 还提供了两个参数的版本：public void join(long millis, int nanos) 这个可以更高精度的等待，这里就不多说了。
2. 休眠当前线程
这个方法在前面也使用过，这里就来更细入的介绍一下。
让线程休眠，本质上就是让这个线程不参与调度了(不去 CPU 上执行了)。
通过调用 Thread 类中的 sleep 静态方法，传入指定时间，就能令线程休眠了。
注意：哪个线程里调用 Thread.sleep(1000)，就让哪个线程休眠 1000 毫秒！
回顾一下上面讲过的知识，如果 main 线程中调用 t.join()，表示 main 线程要等待 t 线程结束，并且 main 线程进入阻塞状态。
而现在所讲的 sleep 方法，本质上是让线程休眠，也是进入了阻塞状态！
如何阻塞？这里需要了解两个玩意，就绪队列，阻塞队列。
当线程 A 调用 sleep() 方法，就会进入一个阻塞队列，当 sleep 结束，就会进入到就绪队列中。
阻塞队列里的线程，也就是暂时不参与 CPU 的调度了，就绪队列中的线程，随时可以被 CPU 调度！
所以一旦线程进入阻塞状态，对应的 PCB 就进入阻塞队列了， 因此暂时不能被 CPU 调度了，那如果线程阻塞结束，对应 PCB 进入到就绪队列，就一定会立即被 CPU 调度到吗？不一定！
这里一定要明确，CPU 是随机调度的！
这里来看一段代码：
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(() -> {
while (true) {
System.out.println("hello");
}
});
t.start();
Thread.sleep(5000);
System.out.println("main 继续执行");
}这里 t 线程死循环打印 "hello"，而 main 线程中休眠了 5000ms，那么一定刚好休眠 5000ms 后就打印 "main 线程继续执行" 吗？
不一定！此时虽然是 sleep(5000)，但实际上考虑到调度的开销，对应线程是无法在唤醒之后就立即执行的，所以实际上的时间大概率要大于 5000ms。
3. 线程的状态
3.1 认识线程的六种状态
线程的状态是一个枚举类型 Thread.State，一个线程从创建到销毁都有着不同的状态。
这里就看下这个 State 枚举类型里面包含的所有状态：
public static void main(String[] args) throws InterruptedException {
for (Thread.State s : Thread.State.values()) {
System.out.println(s);
}
}
● NEW 状态：创建了 Thread 对象，但是还没有调用 start 方法(内核中还没创建 PCB)
● TERMINATED：表示内核中的 PCB 已经执行完毕了(run执行完了)，但是 Thread 对象还在
● RUNNABLE：就绪状态，细分 1) 等待被 CPU 调度，2) 正在 CPU 上执行，但在 Java 中，没有 运行时状态，都是 RUNNABLE(就绪) 状态
● WAITING：调用 wait 或 join 时进入的状态，后面介绍
● TIMED_WAITING：调用 sleep 进入的状态
● BLOCKED：等待锁时产生的状态
最后这三个状态都是阻塞状态，都表示线程的 PCB 在阻塞队列中，只是为啥阻塞的原因不同而已，这些在后续内容中会详细展开介绍。
3.2 线程的状态转换
从这一节开始就提到过，一个线程从创建到销毁都有着不同的状态，下面就用一张简图和多段代码来理解线程工作中不同状态的转换。
下面就来看几段代码，通过代码来观察下线程的状态：
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(() -> {
for (int i = 0; i < 10_0000; i++) {
}
});
System.out.println("start 之前: " + t.getState());
t.start();
System.out.println("线程执行中的状态 : " + t.getState());
Thread.sleep(10);
System.out.println("线程结束后的状态 : " + t.getState());
}
当线程进入 TERMINATED 状态后，对应的 PCB 也就销毁了，也就无法再重新启动线程了，否则会抛异常，但是线程对应的对象 t 并没有被释放，我们仍然可以调用这个对象的一些方法属性，但是无法通过多线程来做一些事情了！
通过代码查看线程调用 sleep 进入 TIMED_WAITING 状态：
public static void main(String[] args) {
Thread t = new Thread(() -> {
for (int i = 0; i < 1000; i++) {
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.start();
for (int i = 0; i < 1000; i++) {
System.out.println("t 的状态: " + t.getState());
}
}
这里发现大量打印 TIMED_WAITING 状态是因为线程执行的 sleep(1) 休眠时间太长了(站在 CPU 的视角)，CPU 1 毫秒可以做很多事，对于执行线程中的 for 循环来说，只会转瞬即逝，所以该线程大部分时间都在休眠，真正在 CPU 上执行的时间特别少，所以也就出现 TIMED_WAITING 状态比 RUNNABLE 多特别多！
目前只演示这四个状态，剩下的 WAITING，BLOCKED 等后续学习到了，会进行讲解。
4. 多线程的优势
前面讲了那么多多线程的理论知识，还很少写过代码，那么现在我们就来通过一小段代码来一下多线程的优势在哪。
● 现有两个变量 a，b 用两个循环对这两个变量分别自增 100 亿次：
单线程实现：
public static void main(String[] args) {
long a = 0;
long b = 0;
long begin = System.currentTimeMillis(); //开始时间
for (long i = 0; i < 100_00000000L; i++) {
a++;
}
for (long i = 0; i < 100_00000000L; i++) {
b++;
}
long end = System.currentTimeMillis(); //结束时间
System.out.println(end - begin + " ms");
}
// 打印结果：5097 ms多线程实现：
public static void main(String[] args) throws InterruptedException {
long begin = System.currentTimeMillis(); //开始时间
Thread t1 = new Thread(() -> {
int a = 0;
for (long i = 0; i < 100_00000000L; i++) {
a++;
}
});
Thread t2 = new Thread(() -> {
int b = 0;
for (long i = 0; i < 100_00000000L; i++) {
b++;
}
});
t1.start();
t2.start();
t1.join();
t2.join();
long end = System.currentTimeMillis(); //结束时间
System.out.println(end - begin + " ms");
}
// 打印结果：2817 ms上述两种实现方式，在不同配置的电脑上，执行的时间都不一样，但多线程肯定是比单线程要快的，但这里有个疑问，为啥多线程消耗的时间不是单线程消耗时间的一半呢？
按道理来说，如果单线程跑两个循环需要 5000ms，那用两个线程一个线程跑一个循环，不应该是 2500ms 吗？
实际上，t1 和 t2 在执行过程中，会经历很多次调度，有时候是并发执行的(两个线程在一个核心上快速切换)，有时候是并行执行的(两个线程在不同的核心上执行)，至于什么时候是并发，什么时候是并行？这些都是不确定的，取决于系统的配置，也取决于当前程序运行的环境，如果同一时刻你电脑上跑的程序很多，此时并行的概率就更小了。另外线程的调度也是有开销了，所以上述多线程版本执行时间肯定不会比单线程版本缩短 50%。
通过上述案例，不难发现在这种 CPU 密集型的任务中，多线程有着非常大的作用，可以充分利用 CPU 多核资源，从而加快程序的执行效率。
多线程一定能提高效率吗？
其实也不一定，如果电脑配置特别特别低，CPU 只有双核，其实也提高不了多少。
如果当前电脑跑了特别多程序，CPU 核心都满载了，这个时候启动更多的线程也没啥用。
学习到现在，看似多线程很美好，但殊不知有一个很大的危险正在向我们靠近，这也是多线程编程中让程序猿苦恼的事情，同时也是面试官经常问的问题 —— 线程安全！
下期预告：【多线程】线程安全问题