线程的生命周期

​

1.生命周期的五种状态：

新建状态、就绪状态、运行状态、阻塞状态、死亡状态

• 1.1新建状态

当实例化Thread对象后，线程就处于新建状态，这时线程并没有执行。

public static void main(String[] args){
    Thread thread = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("子线程开始执行");
            System.out.println("子线程执行结束");
        }
    });
}

• 1.2 就绪状态

只要在代码中启动了线程，就会从新建状态，变为就绪状态。

thread.start();

就绪状态属于一种临时状态。处于就绪状态的线程会去抢占CPU，只要抢占成功就会切换到运行状态，失去了cpu执行权，回到就绪状态。

• 1.3 运行状态

运行状态就是开始执行线程的功能。具体就是执行run()方法

Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("子线程开始执行");
        for (int i = 0; i < 10000; i++) {//运行状态 可停止
            System.out.println(i);
        }
        System.out.println("子线程执行结束");
    }
});
thread.start();

在代码执行过程中分为三种情况：

    1. 如果碰到sleep() / wait() / join()等方法会让线程切换为阻塞状态。

    2. 如果调用yield()方法或失去CPU执行权限会切换为就绪状态。

    3. 如果run()方法成功执行完成，或出现问题或被停止(中断)会切换为死亡状态

• 1.4 阻塞状态

阻塞状态时，线程停止执行。让出CPU资源。

处于阻塞状态的线程需要根据情况进行判断是否转换为就绪状态：

    1. 如果是因为sleep()变为阻塞，则休眠时间结束自动切换为就绪状态。

    2. 如果是因为wait()变为阻塞状态，需要调用notify()或notifyAll()手动切换为就绪状态。

    3. 如果因为join()变为阻塞状态，等到join线程执行完成，自动切换为就绪状态。

    4. （已过时）如果是因为suspend()暂停的线程，需要通过resume()激活线程。

• 1.5 死亡状态

死亡状态即线程执行结束。

2.线程中相关方法

• 2.1 stop()方法(已过时)

stop()可以停止一个线程。让线程处于死亡状态，stop()已经过时

stop()可以将运行状态和阻塞状态的线程杀死，并且不抛出任何异常。

stop()太绝对了，什么情况下都能停，并没有任何的提示信息，可能导致混乱结果。

public static void main(String[] args) throws InterruptedException {
    Thread thread = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("子线程开始执行");
            /*for (int i = 0; i < 10000; i++) {//运行状态 可停止
                System.out.println(i);
            }*/
            try {//阻塞状态 可停止
                Thread.sleep(100000000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程执行结束");
        }
    });
    thread.start();

    Thread.sleep(500);

    thread.stop();
}

• 2.2 interrupt()方法

interrupt()作为stop()的替代方法。可以实现中断线程，并结束该线程。

interrupt()只能中断当前线程状态带有InterruptedException异常的线程，当程序执行过程中，如果被强制中断会出现Interrupted异常。

interrupt() 负责打断处于阻塞状态的线程。防止出现死锁或长时间wait（等待）。

	/*
	    interrupt();
	        中断阻塞状态的线程,线程继续执行，抛出中断异常，
	        运行状态不可以被中断
	    该方法只能中断声明了InterruptException异常状态的线程
	 */
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("开始");
                /*for (int i = 0; i < 1000; i++) {//运行状态 不可中断
                    System.out.println(i);
                }*/
                try {//阻塞状态 可中断
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("结束");
            }
        });
        thread.start();

        Thread.sleep(1000);

        thread.interrupt();
    }

• 2.3 suspend()和resume()
  • 2.3.1 suspend()介绍(已过时)
    suspend()可以挂起、暂停线程，让线程处于阻塞状态，是一个实例方法，已过时。
  • 2.3.2 resume()介绍(已过时)
    resume()可以让suspend()的线程唤醒，变成就绪状态，已过时。

	/*
	    suspend();线程挂起
	    resume();线程恢复
	 */
    private static final String LOCK = "锁";
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                /*synchronized (LOCK) {*/ //有没有锁都可以
                    System.out.println("7777");
                    for (int i = 0; i < 10000; i++) {
                        try {
                            System.out.println(i);
                            Thread.sleep(500);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                /*}*/
            }
        });
        thread.start();
        Thread.sleep(1000);
        thread.suspend();//线程挂起
        Thread.sleep(3000);
        thread.resume();//线程恢复
    }