【Thread】线程的五大状态及守护线程（二）

线程有以下五种状态：创建状态、就绪状态、阻塞状态、运行状态、死亡状态。

它们状态转化如下：

1. 当 new 了一个线程后，线程就处于创建状态：Thread t = new Thread(); 则 t 就处于创建状态；
2. 当线程调用了 start() 方法后，线程就处于就绪状态：t.start(); ，还不是运行状态；
3. 处于就绪状态的线程获取 CPU 资源后，被 CPU 调用，就会处于运行状态，此时，它会执行线程中的 run() 方法；
4. 当一个处于运行状态的线程调用了 sleep() 方法后，它就处于阻塞状态，等待再次被 CPU 调度；
5. 当线程的 run() 方法执行完毕后，线程就处于死亡状态了。此时，再次调用 start() 方法就会报错。

转换状态如下图：

停止线程时，不推荐使用 JDK 中的 stop()、destory() 等方法，推荐使用标志位，让线程自己停下来。

public class TestStop implements Runnable{
	// 标志位
    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag) {
            System.out.println("run...thread" + i++);
        }
    }

	// 对外提供方法，改变标示位
    public void stop() {
        this.flag = false;
    }

    public static void main(String[] args) throws Exception {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();

        Thread.sleep(200);
        for (int i = 0; i < 1000; i++) {
            if (i == 900) {
                testStop.stop();
                System.out.println("线程停止了...");
            }
        }
    }
}

sleep(long)：表示当前线程线程阻塞的毫秒数，它会抛出 InterruptedException 异常；当睡眠时间到达后，线程就会自动处于就绪状态；sleep() 方法并不会释放对象的锁。

案例：模拟倒计时

public class TestSleep {

    public static void tenDown() {
        int num = 10;
        while (true) {
            if (num < 0) {
                break;
            }
            try {
                System.out.println(num--);
                Thread.sleep(1000);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        tenDown();
    }
}

yield()：礼让线程，让当前正在执行的线程暂停，但不阻塞（将线程从运行状态转换为就绪状态），但不一定成功，完全取决于 CPU。简单来说，就是让 CPU 重新调度线程。

public class TestYield {

    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield, "a").start();
        new Thread(myYield, "b").start();
    }
}

class MyYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程开始执行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName() + "线程执行结束");
    }
}

运行结果如下：

这是线程礼让成功了。a 线程先执行，然后 b 线程又执行了

join()：待此线程执行完后，再执行其它线程，其它线程处于阻塞状态。

public class TestState {

    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            System.out.println("/");
        });

        // NEW
        Thread.State state = thread.getState();
        System.out.println(state);

        // RUNNABLE
        thread.start();
        state = thread.getState();
        System.out.println(state);

        while (state != Thread.State.TERMINATED) {
            try {
                Thread.sleep(100);
            } catch (Exception e) {
                e.printStackTrace();
            }
            state = thread.getState();
            System.out.println(state);
        }
    }
}

线程分为：用户线程、守护线程（daemon）。虚拟机必须确保用户线程执行完毕，不用等待守护线程（后台记录操作日志、垃圾回收）执行完毕。

案例：

public class TestDaemon {

    public static void main(String[] args) {
        God god = new God();
        You you = new You();

        Thread thread = new Thread(god);
        // 设置为守护线程。默认为用户线程
        thread.setDaemon(true);
        thread.start();

        new Thread(you).start();
    }

}

class God implements Runnable {

    @Override
    public void run() {
        while (true) {
            System.out.println("上帝一直保佑你!");
        }
    }
}

class You implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 365000; i++) {
            System.out.println("你一生都开心地活着~~");
        }
        System.out.println("=====goodbye!world=====");
    }
}

执行上述程序后，当线程 You 执行完一段时间后，main 线程也结束了，没有理会守护线程 God（它在一直运行着）。如果 God 不为守护线程，那么 main 线程将会一直执行。