【Thread】线程的五大状态、常用方法及守护线程（二）

电玩女神 2023-10-02 12:56 7阅读 0赞

### 1. 线程的状态介绍 ###

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

它们状态转化如下：

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

> 当一个线程调用完一次 start() 方法后，再次调用时，为什么会抛出异常 `java.lang.IllegalThreadStateException`

查看 `Thread` 类:

public class Thread {
        
    	private volatile int threadStatus = 0;
    	
    	public synchronized void start() {
        
            if (threadStatus != 0)
                throw new IllegalThreadStateException();
            // ...
    		
    		boolean started = false;
            try {
        
            	// 属性值 threadStatus 在此方法中修改
                start0();
                started = true;
        	}
        	// ...
    	}
    	
    	// 本地方法
    	private native void start0();
    }

在 `start()` 方法中会判断属性值 `threadStatus`，如果不为 0，则会抛出异常。

通过 debug 发现，`threadStatus` 值是在方法 `start0()` 中进行修改的，而此方法是一个 native 方法，底层是通过 C/C++ 修改的。Java 无法查看。

转换状态如下图：  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc2NvNTI4Mg_size_20_color_FFFFFF_t_70_g_se_x_16]

### 2. 线程中的方法 ###

#### 2.1 线程停止 ####

停止线程时，不推荐使用 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("线程停止了...");
                }
            }
        }
    }

#### 2.2 线程休眠 sleep() ####

`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();
        }
    }

#### 2.3 线程礼让 yield() ####

`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 线程又执行了  
![在这里插入图片描述][4d1bac45785142bf813de64326038902.png]

#### 2.4 线程合并 join() ####

join()：可以将两个交替执行的线程合并为顺序执行的线程。待此线程执行完后，再执行其它线程，其它线程处于阻塞状态。

public class MyJoin extends Thread {
        
    
        @Override
        public void run() {
        
            System.out.println("【子线程】开始,开始时间：" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            try {
        
                System.out.println("执行任务");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            System.out.println("【子线程】结束,结束时间：" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        }
    
        public static void main(String[] args) {
        
            System.out.println("【主线程】开始,开始时间：" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            Thread t = new MyJoin();
            t.start();
            System.out.println("【主线程】结束,结束时间：" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        }
    }

运行结果如下：  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAc2NvNTI4Mg_size_20_color_FFFFFF_t_70_g_se_x_16]  
由运行结果知：主线程和子线程互相不干扰，主线程先执行完毕。

在主线程中调用了子线程的 `join()` 方法后：

public static void main(String[] args) {
        
        System.out.println("【主线程】开始,开始时间：" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        Thread t = new MyJoin();
        t.start();
        try {
        
            t.join();
        } catch (InterruptedException e) {
        
            e.printStackTrace();
        }
        System.out.println("【主线程】结束,结束时间：" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
    }

运行结果如下：  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAc2NvNTI4Mg_size_20_color_FFFFFF_t_70_g_se_x_16 1]  
发现：主线程会等在子线程执行完毕。

#### 2.5 线程状态转化 ####

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);
            }
        }
    }

### 3. 守护线程 ###

线程分为：用户线程、守护线程（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 线程将会一直执行。

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc2NvNTI4Mg_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/9ca30c7703d44caea1c44e9aa14905ee.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBAc2NvNTI4Mg==,size_20,color_FFFFFF,t_70,g_se,x_16
[4d1bac45785142bf813de64326038902.png]: https://img-blog.csdnimg.cn/4d1bac45785142bf813de64326038902.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAc2NvNTI4Mg_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/c06ccb71f4214da38a3ec8c088da12ff.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAc2NvNTI4Mg==,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAc2NvNTI4Mg_size_20_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/3d36fa0a21e6461995522e13e3a0b231.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAc2NvNTI4Mg==,size_20,color_FFFFFF,t_70,g_se,x_16