29--多线程的创建与生命周期

1、相关概念

1.1 程序、进程与线程

程序（program）：为完成特定任务，用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

进程（process）：程序的一次执行过程，或是正在内存中运行的应用程序。如：运行中的QQ，运行中的网易音乐播放器。

• 每个进程都有一个独立的内存空间，系统运行一个程序即是一个进程从创建、运行到消亡的过程。（生命周期）
• 程序是静态的，进程是动态的
• 进程作为操作系统调度和分配资源的最小单位（亦是系统运行程序的基本单位），系统在运行时会为每个进程分配不同的内存区域。
• 现代的操作系统，大都是支持多进程的，支持同时运行多个程序。比如：现在我们上课一边使用编辑器，一边使用录屏软件，同时还开着画图板，dos窗口等软件。

线程（thread）：进程可进一步细化为线程，是程序内部的一条执行路径。一个进程中至少有一个线程。

• 一个进程同一时间若并行执行多个线程，就是支持多线程的。

• 线程作为CPU调度和执行的最小单位。
• 一个进程中的多个线程共享相同的内存单元，它们从同一个堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。
• 下图中，红框的区域为线程独享，黄色区域为线程共享。

注意：

????????不同的进程之间是不共享内存的。

????????进程之间的数据交换和通信的成本很高。

1.2 查看进程和线程

我们可以在电脑底部任务栏，右键----->打开任务管理器，可以查看当前任务的进程：

1、每个应用程序的运行都是一个进程

2、一个应用程序的多次运行，就是多个进程

3、一个进程中包含多个线程

1.3 线程调度

分时调度所有线程轮流使用 CPU 的使用权，并且平均分配每个线程占用 CPU 的时间。

抢占式调度让优先级高的线程以较大的概率优先使用 CPU。如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

1.4 多线程程序的优点

背景：以单核CPU为例，只使用单个线程先后完成多个任务（调用多个方法），肯定比用多个线程来完成用的时间更短，为何仍需多线程呢？

多线程程序的优点：

1. 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
2. 提高计算机系统CPU的利用率
3. 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

1.5 补充概念

1.5.1 单核CPU和多核CPU

单核CPU，在一个时间单元内，只能执行一个线程的任务。例如，可以把CPU看成是医院的医生诊室，在一定时间内只能给一个病人诊断治疗。所以单核CPU就是，代码经过前面一系列的前导操作（类似于医院挂号，比如有10个窗口挂号），然后到cpu处执行时发现，就只有一个CPU（对应一个医生），大家排队执行。

这时候想要提升系统性能，只有两个办法，要么提升CPU性能（让医生看病快点），要么多加几个CPU（多整几个医生），即为多核的CPU。

问题：多核的效率是单核的倍数吗？譬如4核A53的cpu，性能是单核A53的4倍吗？理论上是，但是实际不可能，至少有两方面的损耗。

• 一个是多个核心的其他共用资源限制。譬如，4核CPU对应的内存、cache、寄存器并没有同步扩充4倍。这就好像医院一样，1个医生换4个医生，但是做B超检查的还是一台机器，性能瓶颈就从医生转到B超检查了。
• 另一个是多核CPU之间的协调管理损耗。譬如多个核心同时运行两个相关的任务，需要考虑任务同步，这也需要消耗额外性能。好比公司工作，一个人的时候至少不用开会浪费时间，自己跟自己商量就行了。两个人就要开会同步工作，协调分配，所以工作效率绝对不可能达到2倍。

1.5.2 并行与并发

并行（parallel）：指两个或多个事件在同一时刻发生（同时发生）。指在同一时刻，有多条指令在多个CPU上同时执行。比如：多个人同时做不同的事。

并发（concurrency）：指两个或多个事件在同一个时间段内发生。即在一段时间内，有多条指令在单个CPU上快速轮换、交替执行，使得在宏观上具有多个进程同时执行的效果。

在操作系统中，启动了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单核 CPU 系统中，每一时刻只能有一个程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。

而在多核 CPU 系统中，则这些可以并发执行的程序便可以分配到多个CPU上，实现多任务并行执行，即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行。目前电脑市场上说的多核 CPU，便是多核处理器，核越多，并行处理的程序越多，能大大的提高电脑运行的效率。

2、创建和启动线程

2.1 概述

Java语言的JVM允许程序运行多个线程，使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。

Thread类的特性

• 每个线程都是通过某个特定Thread对象的run()方法来完成操作的，因此把run()方法体称为线程执行体。
• 通过该Thread对象的start()方法来启动这个线程，而非直接调用run()
• 要想实现多线程，必须在主线程中创建新的线程对象。

2.2 方式1：继承Thread类

Java通过继承Thread类来创建并启动多线程的步骤如下：

1. 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务
2. 创建Thread子类的实例，即创建了线程对象
3. 调用线程对象的start()方法来启动该线程

代码如下：

package com.suyv.test01;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 11:02
 * @Description: 自定义线程类
 */
public class MyThread extends Thread{

    public MyThread() {
    }

    //定义指定线程名称的构造方法
    public MyThread(String name) {
        //调用父类的String参数的构造方法，指定线程的名称
        super(name);
    }

    // 重写run()方法
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+"：正在执行！"+i);
        }
    }
}

测试类：

package com.suyv.test01;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 11:05
 * @Description: 测试MyThread
 */
public class TestMyThread {

    public static void main(String[] args) {
        // 创建自定义线程对象1
        MyThread m1 = new MyThread("线程1");
        // 开启子线程1
        m1.start();

        // 创建自定义线程对象2
        MyThread m2 = new MyThread("线程2");
        // 开启子线程2
        m2.start();

        //在主方法中执行for循环
        for (int i = 0; i < 10; i++) {
            System.out.println("main线程！"+i);
        }

    }
}

注意：

如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。

run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU调度决定。

想要启动多线程，必须调用start方法。

一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上的异常IllegalThreadStateException

2.3 方式2：实现Runnable接口

Java有单继承的限制，当我们无法继承Thread类时，那么该如何做呢？在核心类库中提供了Runnable接口，我们可以实现Runnable接口，重写run()方法，然后再通过Thread类的对象代理启动和执行我们的线程体run()方法

步骤如下：

1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
2. 创建Runnable实现类的实例，并以此实例作为Thread的target参数来创建Thread对象，该Thread对象才是真正的线程对象。
3. 调用线程对象的start()方法，启动线程。调用Runnable接口实现类的run方法。

代码如下：

package com.suyv.test02;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 11:12
 * @Description: 自定义线程类
 */
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"：正在执行！"+i);
        }
    }
}

测试类：

package com.suyv.test02;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 11:13
 * @Description: 测试 MyRunnable
 */
public class TestMyRunnable {

    public static void main(String[] args) {
        //创建自定义类对象  线程任务对象
        MyRunnable myRunnable = new MyRunnable();

        //创建线程对象
        Thread t1 = new Thread(myRunnable,"线程1");
        Thread t2 = new Thread(myRunnable,"线程2");

        // 开启子线程
        t1.start();
        t2.start();

        //在主方法中执行for循环
        for (int i = 0; i < 10; i++) {
            System.out.println("main线程！"+i);
        }

    }

}

通过实现Runnable接口，使得该类有了多线程类的特征。所有的分线程要执行的代码都在run方法里面。

在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread对象的start()方法来运行多线程代码。

实际上，所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是继承Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。

说明：Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线程执行体。而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。

2.4 变形写法

使用匿名内部类对象来实现线程的创建和启动

2.4.1 继承Thread写法

package com.suyv.test01;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 11:29
 * @Description: 使用匿名内部类实现继承Thread的方式启动多线程
 */
public class TestThread {

    public static void main(String[] args) {

        // 子线程调用start()方法
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName()+"：正在执行！"+i);
                }
            }
        }.start();

        // 主线程
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"：正在执行！"+i);
        }

    }
}

2.2.4 实现Runnable

package com.suyv.test02;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 11:32
 * @Description: 使用匿名内部类实现实现Runnable的方式启动多线程
 */
public class TestRunnable {

    public static void main(String[] args) {

        // 子线程调用start()方法
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName()+"：正在执行！"+i);
                }
            }
        }).start();

        // 主线程
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"：正在执行！"+i);
        }
    }
}

2.5 对比两种方式

联系

Thread类实际上也是实现了Runnable接口的类。即：public class Thread extends Object implements Runnable

区别

• 继承Thread：线程代码存放Thread子类run方法中。
• 实现Runnable：线程代码存在接口的子类的run方法。

实现Runnable接口比继承Thread类所具有的优势

• 避免了单继承的局限性
• 多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。
• 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

2.6 练习

创建两个分线程，让其中一个线程输出1-100之间的偶数，另一个线程输出1-100之间的奇数。

2.6.1 方式1

package com.suyv.test03;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 12:13
 * @Description: 创建两个分线程，让其中一个线程输出1-100之间的偶数，另一个线程输出1-100之间的奇数。
 */

// 用于打印偶数
public class EvenNumberPrint extends Thread{

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

// 用于打印奇数
class oddNumberPrint extends Thread{

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            if (i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

class Test01{
    public static void main(String[] args) {
        EvenNumberPrint even = new EvenNumberPrint();

        oddNumberPrint odd = new oddNumberPrint();

        even.start();
        odd.start();
    }
}

2.6.2 方式2

package com.suyv.test03;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 12:19
 * @Description: 创建两个分线程，让其中一个线程输出1-100之间的偶数，另一个线程输出1-100之间的奇数。
 */
public class Test02 {
    public static void main(String[] args) {
        // 打印偶数
        new Thread(){
            @Override
            public void run() {
                for (int i = 1; i <= 100; i++) {
                    if (i % 2 == 0){
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                    }
                }
            }
        }.start();

        // 打印奇数
        new Thread(){
            @Override
            public void run() {
                for (int i = 1; i <= 100; i++) {
                    if (i % 2 != 0){
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                    }
                }
            }
        }.start();
    }
}

2.6.3 方式3

package com.suyv.test03;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 12:21
 * @Description: 创建两个分线程，让其中一个线程输出1-100之间的偶数，另一个线程输出1-100之间的奇数。
 */
public class Test03 {

    public static void main(String[] args) {

        // 打印偶数
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 100; i++) {
                    if (i % 2 == 0){
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                    }
                }
            }
        }).start();

        // 打印奇数
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 100; i++) {
                    if (i % 2 != 0){
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                    }
                }
            }
        }).start();
    }
}

3、Thread类的常用结构

3.1 构造器

• public Thread() :分配一个新的线程对象。
• public Thread(String name) :分配一个指定名字的新的线程对象。
• public Thread(Runnable target) :指定创建线程的目标对象，它实现了Runnable接口中的run方法
• public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。

3.2 常用方法系列1

• public void run() :此线程要执行的任务在此处定义代码。
• public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
• public String getName() :获取当前线程名称。
• public void setName(String name)：设置该线程名称。
• public static Thread currentThread() :返回对当前正在执行的线程对象的引用。在Thread子类中就是this，通常用于主线程和Runnable实现类
• public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
• public static void yield()：yield只是让当前线程暂停一下，让系统的线程调度器重新调度一次，希望优先级与当前线程相同或更高的其他线程能够获得执行机会，但是这个不能保证，完全有可能的情况是，当某个线程调用了yield方法暂停之后，线程调度器又将其调度出来重新执行。

3.2.1 线程休眠

package com.suyv.test04;

import java.util.Date;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 13:15
 * @Description: 线程休眠
 */
public class ThreadSleepTest {
    public static void main(String[] args) {
        ThreadSleep threadSleep = new ThreadSleep();

        Thread t1 = new Thread(threadSleep);
        Thread t2 = new Thread(threadSleep);
        Thread t3 = new Thread(threadSleep);

        // 修改线程名
        t1.setName("线程1");
        t2.setName("线程2");
        t3.setName("线程3");

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

class ThreadSleep implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i <= 10 ; i++) {
            System.out.println(Thread.currentThread().getName()+":　"+i+", 日期："+ new Date());

            //困了，我睡一会
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

3.2.2 线程礼让

package com.suyv.test04;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 13:26
 * @Description: 线程礼让
 */
public class ThreadYieldTest {
    public static void main(String[] args) {
        ThreadYield t1 = new ThreadYield();
        ThreadYield t2 = new ThreadYield();

        t1.setName("线程1");
        t2.setName("线程2");

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

class ThreadYield extends Thread{

    @Override
    public void run() {
        for (int i = 0; i <= 10 ; i++) {
            System.out.println(getName()+": "+ i );

            //线程礼让
            Thread.yield();

        }
    }
}

3.3 常用方法系列2

• public final boolean isAlive()：测试线程是否处于活动状态。如果线程已经启动且尚未终止，则为活动状态。
• void join() ：等待该线程终止。 void join(long millis) ：等待该线程终止的时间最长为 millis 毫秒。如果millis时间到，将不再等待。 void join(long millis, int nanos) ：等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。
• public final void stop()：已过时，不建议使用。强行结束一个线程的执行，直接进入死亡状态。run()即刻停止，可能会导致一些清理性的工作得不到完成，如文件，数据库等的关闭。同时，会立即释放该线程所持有的所有的锁，导致数据得不到同步的处理，出现数据不一致的问题。
• void suspend() / void resume() : 这两个操作就好比播放器的暂停和恢复。二者必须成对出现，否则非常容易发生死锁。suspend()调用会导致线程暂停，但不会释放任何锁资源，导致其它线程都无法访问被它占用的锁，直到调用resume()。已过时，不建议使用。

3.3.1 线程加入

package com.suyv.test04;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 13:21
 * @Description: 线程加入
 */
public class ThreadJoinTest {

    public static void main(String[] args) {
        ThreadJoin t1 = new ThreadJoin();
        ThreadJoin t2 = new ThreadJoin();
        ThreadJoin t3 = new ThreadJoin();

        t1.setName("线程1");
        t2.setName("线程2");
        t3.setName("线程3");

        t1.start();
        try {
            t1.join();//加入线程，t1走完之后，t2,t3才可以去抢
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        t2.start();
        t3.start();

    }
}

class ThreadJoin extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <= 10 ; i++) {
            System.out.println(getName()+": "+i);
        }
    }
}

3.3.2 线程停止

package com.suyv.test04;

import java.util.Date;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 13:49
 * @Description: 线程停止
 */
public class ThreadStopTest {
    public static void main(String[] args) {

        ThreadStop t1 = new ThreadStop();
        t1.start();

        try {
            // 如果你睡3秒还不睡醒，就干掉你
            Thread.sleep(3000);
            // t1.stop();// 已过时，但可以用。如果后面还有代码就不没去运行
            t1.interrupt();// 判断当前线程中断，不影响后面的执行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

class ThreadStop extends Thread{

    @Override
    public void run() {
        System.out.println("开始执行："+new Date());
        try {
            Thread.sleep(10000);// 睡了10秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("结果执行："+new Date());
    }
}

3.4 常用方法系列3

每个线程都有一定的优先级，同优先级线程组成先进先出队列（先到先服务），使用分时调度策略。优先级高的线程采用抢占式策略，获得较多的执行机会。每个线程默认的优先级都与创建它的父线程具有相同的优先级。

Thread类的三个优先级常量：

????????MAX_PRIORITY（10）：最高优先级

????????MIN _PRIORITY （1）：最低优先级

????????NORM_PRIORITY （5）：普通优先级，默认情况下main线程具有普通优先级。????????

public final int getPriority() ：返回线程优先级

public final void setPriority(int newPriority) ：改变线程的优先级，范围在[1,10]之间。

package com.suyv.test04;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 13:07
 * @Description: 设置线程优先级
 */
public class ThreadPriorityTest {

    public static void main(String[] args) {

        ThreadPriority t1 = new ThreadPriority();
        ThreadPriority t2 = new ThreadPriority();
        ThreadPriority t3 = new ThreadPriority();

        // 设置优先级只是尽可以保证线程的优先级并不能完全保证，线程本身就是随机
        t1.setPriority(Thread.MAX_PRIORITY);        // 10
        t2.setPriority(Thread.NORM_PRIORITY);       // 5
        t2.setPriority(Thread.MIN_PRIORITY);        // 1

        System.out.println(t1.getPriority());
        System.out.println(t2.getPriority());
        System.out.println(t3.getPriority());

        t1.start();
        t2.start();
        t3.start();

    }
}

class ThreadPriority extends Thread{

    @Override
    public void run() {
        for (int i = 1; i <= 10 ; i++) {
            System.out.println(getName()+":"+i);
        }
    }
}

3.5 守护线程（了解）

有一种线程，它是在后台运行的，它的任务是为其他线程提供服务的，这种线程被称为“守护线程”。JVM的垃圾回收线程就是典型的守护线程。

守护线程有个特点，就是如果所有非守护线程都死亡，那么守护线程自动死亡。形象理解：兔死狗烹，鸟尽弓藏

调用setDaemon(true)方法可将指定线程设置为守护线程。必须在线程启动之前设置，否则会报IllegalThreadStateException异常。

调用isDaemon()可以判断线程是否是守护线程。

package com.suyv.test04;

/**
 * @Author: 憨憨浩浩
 * @CreateTime: 2023-12-25 13:30
 * @Description: 守护线程
 */
public class ThreadDaemonTest {

    public static void main(String[] args) {
        ThreadDaemon t1 = new ThreadDaemon();
        ThreadDaemon t2 = new ThreadDaemon();

        t1.setName("线程1");
        t2.setName("线程2");

        // 设置守护线程，一定在启动之前调用
        t1.setDaemon(true);
        t2.setDaemon(true);

        // 判断线程是否是守护线程
        System.out.println(t1.isDaemon());
        System.out.println(t2.isDaemon());

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

        Thread.currentThread().setName("main线程");
        for (int i = 1; i <=5 ; i++) { // 主线程，main方法，当前线程走到5的时候，t1,t2都会挂掉
            System.out.println(Thread.currentThread().getName()+": "+i);
        }

    }
}

class ThreadDaemon extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {

            System.out.println(getName()+":　"+i);

        }
    }
}

4. 多线程的生命周期

Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下一些状态：

4.1 JDK1.5之前：5种状态

线程的生命周期有五种状态：新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）、死亡（Dead）。CPU需要在多条线程之间切换，于是线程状态会多次在运行、阻塞、就绪之间切换。

1.新建

当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态。此时它和其他Java对象一样，仅仅由JVM为其分配了内存，并初始化了实例变量的值。此时的线程对象并没有任何线程的动态特征，程序也不会执行它的线程体run()。

2.就绪

但是当线程对象调用了start()方法之后，就不一样了，线程就从新建状态转为就绪状态。JVM会为其创建方法调用栈和程序计数器，当然，处于这个状态中的线程并没有开始运行，只是表示已具备了运行的条件，随时可以被调度。至于什么时候被调度，取决于JVM里线程调度器的调度。

注意：程序只能对新建状态的线程调用start()，并且只能调用一次，如果对非新建状态的线程，如已启动的线程或已死亡的线程调用start()都会报错IllegalThreadStateException异常。

3.运行

如果处于就绪状态的线程获得了CPU资源时，开始执行run()方法的线程体代码，则该线程处于运行状态。如果计算机只有一个CPU核心，在任何时刻只有一个线程处于运行状态，如果计算机有多个核心，将会有多个线程并行(Parallel)执行。

当然，美好的时光总是短暂的，而且CPU讲究雨露均沾。对于抢占式策略的系统而言，系统会给每个可执行的线程一个小时间段来处理任务，当该时间用完，系统会剥夺该线程所占用的资源，让其回到就绪状态等待下一次被调度。此时其他线程将获得执行机会，而在选择下一个线程时，系统会适当考虑线程的优先级。

4.阻塞

当在运行过程中的线程遇到如下情况时，会让出 CPU 并临时中止自己的执行，进入阻塞状态：

• 线程调用了sleep()方法，主动放弃所占用的CPU资源；
• 线程试图获取一个同步监视器，但该同步监视器正被其他线程持有；
• 线程执行过程中，同步监视器调用了wait()，让它等待某个通知（notify）；
• 线程执行过程中，同步监视器调用了wait(time)
• 线程执行过程中，遇到了其他线程对象的加塞（join）；
• 线程被调用suspend方法被挂起（已过时，因为容易发生死锁）；

当前正在执行的线程被阻塞后，其他线程就有机会执行了。针对如上情况，当发生如下情况时会解除阻塞，让该线程重新进入就绪状态，等待线程调度器再次调度它：

• 线程的sleep()时间到；
• 线程成功获得了同步监视器；
• 线程等到了通知(notify)；
• 线程wait的时间到了
• 加塞的线程结束了；
• 被挂起的线程又被调用了resume恢复方法（已过时，因为容易发生死锁）；

5.死亡

线程会以以下三种方式之一结束，结束后的线程就处于死亡状态：

• run()方法执行完成，线程正常结束
• 线程执行过程中抛出了一个未捕获的异常（Exception）或错误（Error）
• 直接调用该线程的stop()来结束该线程（已过时）

4.2 JDK1.5及之后：6种状态

在java.lang.Thread.State的枚举类中这样定义：

public enum State {
    NEW,
    RUNNABLE,
    BLOCKED,
    WAITING,
    TIMED_WAITING,
    TERMINATED;
}

NEW（新建）：线程刚被创建，但是并未启动。还没调用start方法。

RUNNABLE（可运行）：这里没有区分就绪和运行状态。因为对于Java对象来说，只能标记为可运行，至于什么时候运行，不是JVM来控制的了，是OS来进行调度的，而且时间非常短暂，因此对于Java对象的状态来说，无法区分。

Teminated（被终止）：表明此线程已经结束生命周期，终止运行。

重点说明，根据Thread.State的定义，阻塞状态分为三种：BLOCKED、WAITING、TIMED_WAITING。

????????BLOCKED（锁阻塞）：在API中的介绍为：一个正在阻塞、等待一个监视器锁（锁对象）的线程处于这一状态。只有获得锁对象的线程才能有执行机会。比如，线程A与线程B代码中使用同一锁，如果线程A获取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态。

????????TIMED_WAITING（计时等待）：在API中的介绍为：一个正在限时等待另一个线程执行一个（唤醒）动作的线程处于这一状态。当前线程执行过程中遇到Thread类的sleep或join，Object类的wait，LockSupport类的park方法，并且在调用这些方法时，设置了时间，那么当前线程会进入TIMED_WAITING，直到时间到，或被中断。

????????WAITING（无限等待）：在API中介绍为：一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。当前线程执行过程中遇到遇到Object类的wait，Thread类的join，LockSupport类的park方法，并且在调用这些方法时，没有指定时间，那么当前线程会进入WAITING状态，直到被唤醒。

????????通过Object类的wait进入WAITING状态的要有Object的notify/notifyAll唤醒；

????????通过Condition的await进入WAITING状态的要有Condition的signal方法唤醒；

????????通过LockSupport类的park方法进入WAITING状态的要有LockSupport类的unpark方法唤醒

????????通过Thread类的join进入WAITING状态，只有调用join方法的线程对象结束才能让当前线程恢复；

说明：当从WAITING或TIMED_WAITING恢复到Runnable状态时，如果发现当前线程没有得到监视器锁，那么会立刻转入BLOCKED状态。