Java线程的（6种状态及切换）以及（线程优先组和优先级）

1、6种状态及切换

我们先来看看操作系统中的线程状态转换。在操作系统open in new window中，线程被视为轻量级的进程，所以线程状态其实和进程状态是一致的。

操作系统的线程主要有以下三个状态：

就绪状态(ready)：线程正在等待使用 CPU，经调度程序调用之后进入 running 状态。

执行状态(running)：线程正在使用 CPU。

等待状态(waiting): 线程经过等待事件的调用或者正在等待其他资源（如 I/O）。

然后我们来看 Java 线程的 6 个状态：

java 复制代码

// Thread.State 源码
public enum State {
    NEW,
    RUNNABLE,
    BLOCKED,
    WAITING,
    TIMED_WAITING,
    TERMINATED;
}

1.NEW

描述：线程被创建但是尚未启动

用法：当你创建一个新的Thread示例的时候，它就处于这个状态。要使线程开始执行，调用start()方法。

java 复制代码

private void testStateNew() {
    Thread thread = new Thread(() -> {});
    System.out.println(thread.getState()); // 输出 NEW
}

在这里例子中，线程在调用start()之前处于NEW的状态

关于 start 的两个引申问题

反复调用同一个线程的 start 方法是否可行？

假如一个线程执行完毕（此时处于 TERMINATED 状态），再次调用这个线程的 start 方法是否可行？

要分析这两个问题，我们先来看看start()的源码：

java 复制代码

// 使用synchronized关键字保证这个方法是线程安全的
public synchronized void start() {
    // threadStatus != 0 表示这个线程已经被启动过或已经结束了
    // 如果试图再次启动这个线程，就会抛出IllegalThreadStateException异常
    if (threadStatus != 0)
        throw new IllegalThreadStateException();

    // 将这个线程添加到当前线程的线程组中
    group.add(this);

    // 声明一个变量，用于记录线程是否启动成功
    boolean started = false;
    try {
        // 使用native方法启动这个线程
        start0();
        // 如果没有抛出异常，那么started被设为true，表示线程启动成功
        started = true;
    } finally {
        // 在finally语句块中，无论try语句块中的代码是否抛出异常，都会执行
        try {
            // 如果线程没有启动成功，就从线程组中移除这个线程
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            // 如果在移除线程的过程中发生了异常，我们选择忽略这个异常
        }
    }
}

可以看到，在start()内部，有一个 threadStatus 变量。如果它不等于 0，调用start()会直接抛出异常。

接着往下看，有一个 nativeopen in new window 的 start0() 方法。这个方法并没有对threadStatus进行处理。到这里我们仿佛拿这个 threadStatus 没辙了，通过 debug 再看一下:

java 复制代码

@Test
public void testStartMethod() {
    Thread thread = new Thread(() -> {});
    thread.start(); // 第一次调用
    thread.start(); // 第二次调用
}

在 start 方法内部的最开始打断点：

第一次调用时 threadStatus 的值是 0。

第二次调用时 threadStatus 的值不为 0。

结合上面的源码可以得到的答案是：

都不行，在调用 start 之后，threadStatus 的值会改变（threadStatus !=0），再次调用 start 方法会抛出 IllegalThreadStateException 异常。这是因为一旦线程开始执行，运行状态会发生改变，并且无法安全的重新启动

threadStatus 为 2 代表当前线程状态为 TERMINATED，表示run()方法执行结束，此时线程的生命周期就结束了，再次调用start()方法不会重新启动线程，而是会抛出IllegalThreadStateException。

2.RUNNABLE

描述：线程正在被JAVA虚拟机执行，但可能还在等待操作系统分配处理器资源。

用法：一旦线程调用了start()方法，它就进入了RUNNABLE，这个阶段，线程有机会执行其run()方法中的代码。

3.BLOCKED

描述：线程因为等待监视器锁(也就是等待进入同步方法或块)而被阻塞。

用法：当线程尝试获取一个已经被其他线程持有的锁时，它将进入BLOCKED状态。直到其他线程释放该锁，该线程才能继续执行。

我们用 BLOCKED 状态举个生活中的例子：

假如今天你下班后准备去食堂吃饭。你来到食堂仅有的一个窗口，发现前面已经有个人在窗口前了，此时你必须得等前面的人从窗口离开才行。

假设你是线程 t2，你前面的那个人是线程 t1。此时 t1 占有了锁（食堂唯一的窗口），t2 正在等待锁的释放，所以此时 t2 就处于 BLOCKED 状态。

4.WAITING

描述：等待状态。处于等待状态的线程变成 RUNNABLE 状态需要其他线程唤醒。

用法：线程调用了wait(),join()或LockSupport.park()方法后，将进入WAITING状态。要唤醒处于WAITING状态线程，需要其他线程调用相同的对象的notify()或者notifyAll()方法。

我们延续上面的例子继续解释一下 WAITING 状态：

你等了好几分钟，终于轮到你了，突然你们有一个"不懂事"的经理来了。你看到他你就有一种不祥的预感，果然，他是来找你的。

他把你拉到一旁叫你待会儿再吃饭，说他下午要去作报告，赶紧来找你了解一下项目的情况。你心里虽然有一万个不愿意但是你还是从食堂窗口走开了。

此时，假设你还是线程 t2，你的经理是线程 t1。虽然你此时都占有锁（窗口）了，"不速之客"来了你还是得释放掉锁。此时你 t2 的状态就是 WAITING。然后经理 t1 获得锁，进入 RUNNABLE 状态。

要是经理 t1 不主动唤醒你 t2（notify、notifyAll..），可以说你 t2 只能一直等待了。

5.TIMED_WAITING

描述：与WAITING类似，但是线程等待有时间限制，时间到了之后会被自动唤醒。

用法：

Thread.sleep(long millis)：使当前线程睡眠指定时间；

Object.wait(long timeout)：线程休眠指定时间，等待期间可以通过notify()/notifyAll()唤醒；

Thread.join(long millis)：等待当前线程最多执行 millis 毫秒，如果 millis 为 0，则会一直执行；

LockSupport.parkNanos(long nanos)：除非获得调用许可，否则禁用当前线程进行线程调度指定时间；LockSupportopen in new window 我们在后面会细讲；

LockSupport.parkUntil(long deadline)：同上，也是禁止线程进行调度指定时间；

我们继续延续上面的例子来解释一下 TIMED_WAITING 状态：

到了第二天中午，又到了饭点，你还是到了窗口前。

突然间想起你的同事叫你等他一起，他说让你等他十分钟他改个 bug。

好吧，那就等等吧，你就离开了窗口。很快十分钟过去了，你见他还没来，你想都等了这么久了还不来，那你还是先去吃饭好了。

这时你还是线程 t1，你改 bug 的同事是线程 t2。t2 让 t1 等待了指定时间，此时 t1 等待期间就属于 TIMED_WATING 状态。

t1 等待 10 分钟后，就自动唤醒，拥有了去争夺锁的资格。

6.TERMINTED

描述：线程已经执行完毕，结束了它的执行。

3、线程状态的转换

在java中，线程状态的转换是由java虚拟机(jvm)自动管理的，这些状态转换通常是由线程的执行行为触发的

3.1 BLOCKED 与 RUNNABLE 状态的转换

我们在上面说过：处于 BLOCKED 状态的线程在等待锁的释放。假如这里有两个线程 a 和 b，a 线程提前获得了锁并暂未释放锁，此时 b 就处于 BLOCKED 状态。我们来看一个例子：

java 复制代码

@Test
public void blockedTest() {
    Thread a = new Thread(new Runnable() {
        @Override
        public void run() {
            testMethod();
        }
    }, "a");

    Thread b = new Thread(new Runnable() {
        @Override
        public void run() {
            testMethod();
        }
    }, "b");

    a.start();
    b.start();

    System.out.println(a.getName() + ":" + a.getState()); // 输出？
    System.out.println(b.getName() + ":" + b.getState()); // 输出？
}

// 同步方法争夺锁
private synchronized void testMethod() {
    try {
        Thread.sleep(2000L);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

初看之下，大家可能会觉得线程 a 会先调用同步方法，同步方法内又调用了Thread.sleep()方法，必然会输出 TIMED_WAITING，而线程 b 因为等待线程 a 释放锁所以必然会输出 BLOCKED。

其实不然，有两点需要值得大家注意：

一是在测试方法blockedTest()内还有一个 main 线程

二是启动线程后执行 run 方法还是需要消耗一定时间的。

测试方法的 main 线程只保证了 a，b 两个线程调用 start 方法（转化为 RUNNABLE 状态），如果 CPU 执行效率高一点，还没等两个线程真正开始争夺锁，就已经打印此时两个线程的状态（RUNNABLE）了。

当然，如果 CPU 执行效率低一点，其中某个线程也是可能打印出 BLOCKED 状态的（此时两个线程已经开始争夺锁了）。

过程分析：

当a和b两个线程开始运行的时候，假设a首先获得了锁并开始执行testMethod()。此时，如果线程b尝试调用testMethod()，他将会被阻塞，因为锁已经被a占用。

打印状态的输出是在主线程中执行的，并且是在启动a，b线程之后立即执行，因此，这些语句在a，b线程有机会改变状态之前就打印了它们的状态，如果执行的慢的话。

由于线程a,b刚刚启动，它们很可能来不及进入textMethod()方法体,更不用说进入Thread.sleep了。所以，在大多数情况下，这两个线程还是处于Thread.State.RUNNABLE状态。

但是，如果线程a已经成功获得到了锁并进入了textMethod()中的Thread.sleep,那么他的状态将会是Thread.Stat.TIME_WAITTING;而线程b会因为会无法获取锁，被阻塞在textMethod()的入口处。

这时你可能又会问了，要是我想要打印出 BLOCKED 状态我该怎么处理呢？

BLOCKED 状态的产生需要两个线程争夺锁才行。那我们处理下测试方法里的 main 线程就可以了，让它"休息一会儿"，调用一下Thread.sleep()方法。

这里需要注意的是 main 线程休息的时间，要保证在线程争夺锁的时间内，不要等到前一个线程锁都释放了你再去争夺锁，此时还是得不到 BLOCKED 状态的。

我们把上面的测试方法 blockedTest 改动一下：

java 复制代码

public void blockedTest() throws InterruptedException {
    ······
    a.start();
    Thread.sleep(1000L); // 需要注意这里main线程休眠了1000毫秒，而testMethod()里休眠了2000毫秒
    b.start();
    System.out.println(a.getName() + ":" + a.getState()); // 输出？
    System.out.println(b.getName() + ":" + b.getState()); // 输出？
}

运行结果如下所示：

在这个例子中两个线程的状态转换如下

a 的状态转换过程：RUNNABLE（a.start()） -> TIMED_WATING（Thread.sleep()）->RUNABLE（sleep()时间到）->BLOCKED(未抢到锁) -> TERMINATED

b 的状态转换过程：RUNNABLE（b.start()) -> BLOCKED(未抢到锁) ->TERMINATED

3.2 WAITING 状态与 RUNNABLE 状态的转换

根据转换图我们知道有 3 个方法可以使线程从 RUNNABLE 状态转为 WAITING 状态。我们主要介绍下Object.wait()和Thread.join()。

Object.wait()

调用wait()方法前线程必须持有对象的锁。

线程调用wait()方法时，会释放当前的锁，直到有其他线程调用notify()/notifyAll()方法唤醒等待锁的线程。

需要注意的是，其他线程调用notify()方法只会唤醒单个等待锁的线程，如有有多个线程都在等待这个锁的话不一定会唤醒到之前调用wait()方法的线程。

同样，调用notifyAll()方法唤醒所有等待锁的线程之后，也不一定会马上把时间片分给刚才放弃锁的那个线程，具体要看系统的调度。

Thread.join()

调用join()方法，会一直等待这个线程执行完毕（转换为 TERMINATED 状态）。

我们再把上面的例子线程启动那里改变一下：

java 复制代码

public void blockedTest() {
    ······
    a.start();
    a.join();
    b.start();
    System.out.println(a.getName() + ":" + a.getState()); // 输出 TERMINATED
    System.out.println(b.getName() + ":" + b.getState());
}

要是没有调用 join 方法，main 线程不管 a 线程是否执行完毕都会继续往下走。

a 线程启动之后马上调用了 join 方法，这里 main 线程就会等到 a 线程执行完毕，所以这里 a 线程打印的状态固定是TERMINATED。

至于 b 线程的状态，有可能打印 RUNNABLE（尚未进入同步方法），也有可能打印 TIMED_WAITING（进入了同步方法）。

4、TIMED_WAITING 与 RUNNABLE 状态转换

TIMED_WAITING 与 WAITING 状态类似，只是 TIMED_WAITING 状态等待的时间是指定的。

Thread.sleep(long)

使当前线程睡眠指定时间。需要注意这里的"睡眠"只是暂时使线程停止执行，并不会释放锁。时间到后，线程会重新进入 RUNNABLE 状态。

Object.wait(long)

wait(long)方法使线程进入 TIMED_WAITING 状态。这里的wait(long)方法与无参方法 wait()相同的地方是，都可以通过其他线程调用notify()或notifyAll()方法来唤醒。

不同的地方是，有参方法wait(long)就算其他线程不来唤醒它，经过指定时间 long 之后它会自动唤醒，拥有去争夺锁的资格。

Thread.join(long)

join(long)使当前线程执行指定时间，并且使线程进入 TIMED_WAITING 状态。

我们再来改一改刚才的示例:

java 复制代码

public void blockedTest() {
    ······
    a.start();
    a.join(1000L);
    b.start();
    System.out.println(a.getName() + ":" + a.getState()); // 输出 TIEMD_WAITING
    System.out.println(b.getName() + ":" + b.getState());
}

这里调用a.join(1000L)，因为是指定了具体 a 线程执行的时间的，并且执行时间是小于 a 线程 sleep 的时间，所以 a 线程状态输出 TIMED_WAITING。

b 线程状态仍然不固定（RUNNABLE 或 BLOCKED）。

线程中断

在某些情况下，我们在线程启动后发现并不需要它继续执行下去时，需要中断线程。目前在 Java 里还没有安全方法来直接停止线程，但是 Java 提供了线程中断机制来处理需要中断线程的情况。

线程中断机制是一种协作机制。需要注意，通过中断操作并不能直接终止一个线程，而是通知需要被中断的线程自行处理。

简单介绍下 Thread 类里提供的关于线程中断的几个方法：

Thread.interrupt()：中断线程。这里的中断线程并不会立即停止线程，而是设置线程的中断状态为 true（默认是 flase）；

Thread.isInterrupted()：测试当前线程是否被中断。

Thread.interrupted()：检测当前线程是否被中断，与 isInterrupted() 方法不同的是，这个方法如果发现当前线程被中断，会清除线程的中断状态。

代码举例：

java 复制代码

public class InterruptExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            try {
                // 执行一些长时间运行的任务
                while (!Thread.currentThread().isInterrupted()) {
                    System.out.println("线程正在运行...");
                    Thread.sleep(1000); // 模拟耗时操作
                }
            } catch (InterruptedException e) {
                // 捕获InterruptedException异常，线程被中断时会抛出此异常
                System.out.println("线程被中断");
            }
        });

        thread.start();

        // 稍后中断线程
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 调用interrupt()方法设置中断状态
        thread.interrupt();
    }
}

运行结果：

java 复制代码

线程正在运行...
线程正在运行...
线程正在运行...
线程正在运行...
线程正在运行...
线程被中断

5、线程的优先组和优先级

1.线程组

线程组是一个用来管理多个线程的类，它提供了一种方式来组织和管理线程集合。你可以将一组线程放入一个线程组，并且通过该线程组对象来操作这些线程。例如，你可以暂定，恢复或者停止整个线程组中的所有线程。

ThreadGroup 和 Thread 的关系就如同他们的字面意思一样简单粗暴，每个 Thread 必然存在于一个 ThreadGroup 中，Thread 不能独立于 ThreadGroup 存在。执行main()方法的线程名字是 main，如果在 new Thread 时没有显式指定，那么默认将父线程（当前执行 new Thread 的线程）线程组设置为自己的线程组。

创建线程组：

java 复制代码

ThreadGroup group =new ThreadGroup("MyThreadGroup");

也可以通过指定父线程来创建子线程组：

java 复制代码

ThreadGroup parent=Thread.currentThread().getThreadGrouo();
ThreadGroup child =new ThreadGroup(parent,"childThreadGroup");

使用线程组：

当你创建一个新的线程的时候，可以通过指定线程组来将线程加入到特定的线程组中：

java 复制代码

Thread thread = new Thread(group, new Runnable() {
    @Override
    public void run() {
        // 线程执行代码
    }
}, "MyThread");

练习：

java 复制代码

Thread testThread = new Thread(() -> {
    System.out.println("testThread当前线程组名字：" +
            Thread.currentThread().getThreadGroup().getName());
    System.out.println("testThread线程名字：" +
            Thread.currentThread().getName());
});

testThread.start();
System.out.println("执行main所在线程的线程组名字： " + Thread.currentThread().getThreadGroup().getName());
System.out.println("执行main方法线程名字：" + Thread.currentThread().getName());

输出结果：

java 复制代码

执行main所在线程的线程组名字： main
testThread当前线程组名字：main
testThread线程名字：Thread-0
执行main方法线程名字：main

为什么会这样子运行？

主线程（main）:main方法首先执行，因为他是由jvm来自动启动的。

testThread：是由main方法创建并启动的，它依赖于线程调度器，所以它可能在main方法的输出之后立即开始，也可能稍后开始

ThreadGroup 是一个标准的向下引用 的树状结构，这样设计可以防止"上级"线程被"下级"线程引用而无法有效地被 GC 回收 。

2.线程组的常用方法及数据结构

获取当前线程的线程组名字

java 复制代码

Thread.currentThread().getThreadGroup().getName()

复制线程组：

java 复制代码

// 获取当前的线程组
ThreadGroup threadGroup = Thread.currentThread().getThreadGroup();
// 复制一个线程组到一个线程数组（获取Thread信息）
Thread[] threads = new Thread[threadGroup.activeCount()];
threadGroup.enumerate(threads);

线程组统一异常处理

java 复制代码

// 创建一个线程组，并重新定义异常
ThreadGroup group = new ThreadGroup("testGroup") {
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.out.println(t.getName() + ": " + e.getMessage());
    }
};

// 测试异常
Thread thread = new Thread(group, () -> {
    // 抛出 unchecked 异常
    throw new RuntimeException("测试异常");
});

// 启动线程
thread.start();

线程组的数据结构

线程组还可以包含其他的线程组，不仅仅是线程。首先看看 ThreadGroup源码中的成员变量。

java 复制代码

public class ThreadGroup implements Thread.UncaughtExceptionHandler {
    private final ThreadGroup parent; // 父亲ThreadGroup
    String name; // ThreadGroup 的名称
    int maxPriority; // 最大优先级
    boolean destroyed; // 是否被销毁
    boolean daemon; // 是否守护线程
    boolean vmAllowSuspension; // 是否可以中断

    int nUnstartedThreads = 0; // 还未启动的线程
    int nthreads; // ThreadGroup中线程数目
    Thread threads[]; // ThreadGroup中的线程

    int ngroups; // 线程组数目
    ThreadGroup groups[]; // 线程组数组
}

3.线程的优先级

在java中，线程的优先级是用来影响线程调度的一个因素。线程的优先级越高，被调度器选择执行的概率越大。然而，线程优先级并不是绝对的，实际的线程调度还取决于操作系统和jvm的具体实现。

线程优先级可以指定，范围是 1~10。但并不是所有的操作系统都支持 10 级优先级的划分（比如有些操作系统只支持 3 级划分：低、中、高），Java 只是给操作系统一个优先级的参考值 ，线程最终在操作系统中的优先级还是由操作系统决定。

Java 默认的线程优先级为 5，线程的执行顺序由调度程序来决定，线程的优先级会在线程被调用之前设定。

通常情况下，高优先级的线程将会比低优先级的线程有更高的概率得到执行。Thread类的setPriority()方法可以用来设定线程的优先级，通过getPriority()方法来获取线程当前的优先级。

java 复制代码

Thread a = new Thread();
System.out.println("我是默认线程优先级："+a.getPriority());
Thread b = new Thread();
b.setPriority(10);
System.out.println("我是设置过的线程优先级："+b.getPriority());

输出结果：

java 复制代码

我是默认线程优先级：5
我是设置过的线程优先级：10

既然有 10 个级别来设定线程的优先级，那是不是可以在业务实现的时候，采用这种方法来指定线程执行的先后顺序呢？

对于这个问题，答案是：No!

Java 中的优先级不是特别的可靠，Java 程序中对线程所设置的优先级只是给操作系统一个建议，操作系统不一定会采纳。而真正的调用顺序，是由操作系统的线程调度算法来决定的。

我们通过代码来验证一下：

java 复制代码

static class MyThread extends Thread {
    @Override
    public void run() {
        // 输出当前线程的名字和优先级
        System.out.println("MyThread当前线程：" + Thread.currentThread().getName()
                + ",优先级：" + Thread.currentThread().getPriority());
    }
}

public static void main(String[] args) {
    // 创建 10 个线程，从 1-10 运行，优先级从 1-10
    for (int i = 1; i <= 10; i++) {
        Thread thread = new MyThread();
        thread.setName("线程" + i);
        thread.setPriority(i);
        thread.start();
    }
}

运行结果：

java 复制代码

MyThread当前线程：线程2,优先级：2
MyThread当前线程：线程4,优先级：4
MyThread当前线程：线程3,优先级：3
MyThread当前线程：线程5,优先级：5
MyThread当前线程：线程1,优先级：1
MyThread当前线程：线程6,优先级：6
MyThread当前线程：线程7,优先级：7
MyThread当前线程：线程8,优先级：8
MyThread当前线程：线程9,优先级：9
MyThread当前线程：线程10,优先级：10

Java 提供了一个线程调度器 来监视和控制处于RUNNABLE 状态的线程。

线程的调度策略采用抢占式的方式，优先级高的线程会比优先级低的线程有更大的几率优先执行。

在优先级相同的情况下，会按照"先到先得"的原则执行。

每个 Java 程序都有一个默认的主线程，就是通过 JVM 启动的第一个线程------main 线程。

还有一种特殊的线程，叫做守护线程（Daemon），守护线程默认的优先级比较低。

如果某线程是守护线程，那如果所有的非守护线程都结束了，这个守护线程也会自动结束。

当所有的非守护线程结束时，守护线程会自动关闭，这就免去了还要继续关闭子线程的麻烦。

线程默认是非守护线程，可以通过 Thread 类的 setDaemon 方法来设置为守护线程。

线程组和线程优先级之间的关系

java 复制代码

// 创建一个线程组
ThreadGroup group = new ThreadGroup("testGroup");
// 将线程组的优先级指定为 7
group.setMaxPriority(7);
// 创建一个线程，将该线程加入到 group 中
Thread thread = new Thread(group, "test-thread");
// 企图将线程的优先级设定为 10
thread.setPriority(10);
// 输出线程组的优先级和线程的优先级
System.out.println("线程组的优先级是：" + group.getMaxPriority());
System.out.println("线程的优先级是：" + thread.getPriority());

输出：

java 复制代码

线程组的优先级是：7
线程的优先级是：7

所以，如果某个线程的优先级大于线程所在线程组的最大优先级，那么该线程的优先级将会失效，取而代之的是线程组的最大优先级。