1. 前言

今天以具体实例的方法来详细记录下实战中的sleep, yield, join。到底是什么意思，应该怎么用呢？？？

2. 适合人群

对该类方法的概念比较模糊的人

3. 开始

3.1 `sleep`

此方法是一个静态方法，可以通过类名直接调用Thread.sleep。
调用此方法表示线程进入休眠状态。当前线程会暂停一段时间，将执行权让给其他的线程来执行。唤醒时间由睡眠时间所决定。

    public static void testSleep() throws InterruptedException {
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("A" + i);
                try {
                    Thread.sleep(500);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        }).start();

        System.out.println("开始了....");
        // 此处休眠是让主线程进行休眠
        Thread.sleep(1000);
        System.out.println("结束了...");
    }

使用Thread.sleep 表示所处的线程进行休眠的。
如上述代码所示，当我在lambda表达式中调用此方法的时候，表示上述lambda表达式所处的线程进行休眠
如果想主线程进行休眠的话，可以在主线程中调用函数Thread.sleep

3.2 `yield`

使用Thread.yield的话，当前线程会暂停下来并放入等待队列(线程还是处于就绪状态，随时被CPU调用)。
系统调度算法依旧会从等待队列中随机获取线程并且执行。有可能还是上次放入的线程
总结：使用该API后，将API放入到等待队列中，跟别的等待线程获得同样的被获取执行的机会

    public static void testYield() {
        new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                if (i % 10 == 0) {
                    System.out.println("A: 此时我抢到了..." + i);
                    Thread.yield();
                }
            }
        }).start();

        new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                if (i % 10 == 0) {
                    System.out.println("B: 此时我抢到了..." + i);
                    Thread.yield();
                }
            }
        }).start();
    }

3.3 `join`

此时有线程A, B 两个线程
在B线程中执行了A.join了。说明将A线程添加到B线程中执行。如果B线程想要执行的话，必须等待A线程执行结束
总结：将一个A线程添加到另一个B线程中执行，只有线程A执行结束后，线程B才可以执行。
所以如果是自己jon 自己的话，没有任何意义的

    public static void testJoin() {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("我是线程A" + i);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

        Thread t2 = new Thread(() -> {
            try {
                t1.join();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            for (int i = 0; i < 10; i++) {
                System.out.println("我是线程B" + i);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

        t1.start();
        t2.start();
    }

其实我们都知道线程是异步的，如果我想在主线程中等待子线程执行结束后，才能执行主线程剩余的逻辑怎么办呢？？？下面给大家列举一个例子：

    public static void testMain() throws InterruptedException {
        System.out.println("主线程开始了...");

        Thread t = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(100);
                    System.out.println("这是子线程内容..." + (i + 1));
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

        t.start();
        t.join();

        System.out.println("主线程结束了...");
    }