Java多线程老鸟养成记（二）：线程的状态控制-优快云博客

本文深入探讨Java中线程的控制方法，包括sleep、yield、join等方法的应用场景及注意事项，同时介绍了线程优先级、守护线程的概念及如何安全地结束线程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

0、概述

Java提供了一些API用于线程状态的控制，在上篇文章 Java多线程老鸟养成记（一）：线程的生命周期中已经提到了大多数常用的重要API，下面是来自jdk1.6中文手册中的API

`void`	`destroy()` 已过时。该方法最初用于破坏该线程，但不作任何清除。它所保持的任何监视器都会保持锁定状态。不过，该方法决不会被实现。即使要实现，它也极有可能以suspend方式被死锁。如果目标线程被破坏时保持一个保护关键系统资源的锁，则任何线程在任何时候都无法再次访问该资源。如果另一个线程曾试图锁定该资源，则会出现死锁。这类死锁通常会证明它们自己是“冻结”的进程。
`void`	`interrupt()` 中断线程。
`void`	`join()` 等待该线程终止。
`void`	`join(long millis)` 等待该线程终止的时间最长为 `millis` 毫秒。
`void`	`join(long millis, int nanos)` 等待该线程终止的时间最长为 `millis` 毫秒 + `nanos` 纳秒。
`void`	`resume()` 已过时。该方法只与 `suspend()` 一起使用，但 `suspend()` 已经遭到反对，因为它具有死锁倾向。
`void`	`setDaemon(boolean on)` 将该线程标记为守护线程或用户线程。
`void`	`setPriority(int newPriority)` 更改线程的优先级。
`static void`	`sleep(long millis)` 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
`static void`	`sleep(long millis, int nanos)` 在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
`void`	`start()` 使该线程开始执行；Java 虚拟机调用该线程的 `run` 方法。
`void`	`stop()` 已过时。该方法具有固有的不安全性。用 Thread.stop 来终止线程将释放它已经锁定的所有监视器（作为沿堆栈向上传播的未检查 `ThreadDeath` 异常的一个自然后果）。如果以前受这些监视器保护的任何对象都处于一种不一致的状态，则损坏的对象将对其他线程可见，这有可能导致任意的行为。`stop` 的许多使用都应由只修改某些变量以指示目标线程应该停止运行的代码来取代。目标线程应定期检查该变量，并且如果该变量指示它要停止运行，则从其运行方法依次返回。如果目标线程等待很长时间（例如基于一个条件变量），则应使用 `interrupt` 方法来中断该等待。
`void`	`stop(Throwable obj)` 已过时。该方法具有固有的不安全性。有关详细信息，请参阅 `stop()`。该方法的附加危险是它可用于生成目标线程未准备处理的异常（包括若没有该方法该线程不太可能抛出的已检查的异常）。
`void`	`suspend()` 已过时。该方法已经遭到反对，因为它具有固有的死锁倾向。如果目标线程挂起时在保护关键系统资源的监视器上保持有锁，则在目标线程重新开始以前任何线程都不能访问该资源。如果重新开始目标线程的线程想在调用 `resume` 之前锁定该监视器，则会发生死锁。这类死锁通常会证明自己是“冻结”的进程。
`static void`	`yield()` 暂停当前正在执行的线程对象，并执行其他线程。

可以看到很多方法，已经标注为过时的，我们应该尽可能的避免使用它们，而应该重点关注start()、interrupt()、join()、sleep()、yield()等直接控制方法，和setDaemon()、setPriority()等间接控制方法。

1、线程睡眠——sleep

如果我们需要让当前正在执行的线程暂停一段时间，并进入阻塞状态，则可以通过调用Thread的sleep方法，从上面可以看到sleep方法有两种重载的形式，但是使用方法一样。

比如，我们想要使主线程每休眠1000毫秒，然后再打印出数字：

public class TestSleep {  
    public static void main(String[] args) throws InterruptedException {  
        for(int i=0;i<100;i++){  
            System.out.println("======"+i);  
            Thread.sleep(1000);  
        }  
    }  
}

可以感觉到打印的数字有明显的时间间隔。

注意如下几点问题

①、sleep是静态方法，不要用Thread的实例对象调用它，因为它睡眠的始终是当前正在运行的线程，而不是调用它的线程对象，它只对正在运行状态的线程对象有效。看下面的例子：

public class TestSleep {  
    public static void main(String[] args) throws InterruptedException {  
        System.out.println(Thread.currentThread().getName());  
        Thread t1=new Thread();  
        t1.setName("子线程");
        t1.start();  
        //这里sleep的是main线程，而不是子线程
        t1.sleep(1000);
        Thread.sleep(100);  
        for(int i=0;i<100;i++){  
            System.out.println("========"+i);  
        }  
    }  
}

②、Java线程调度是Java多线程的核心，只有良好的调度，才能充分发挥系统的性能，提高程序的执行效率。但是不管程序员怎么编写调度，只能最大限度的影响线程执行的次序，而不能做到精准控制。因为使用sleep方法之后，线程是进入阻塞状态的，只有当睡眠的时间结束，才会重新进入到就绪状态，而就绪状态进入到运行状态，是由系统控制的，我们不可能精准的去干涉它，所以如果调用Thread.sleep(1000)使得线程睡眠1秒，结果会>=1秒。

2、线程让步——yield

yield()方法和sleep()方法有点相似，它也是Thread类提供的一个静态的方法，它也可以让当前正在执行的线程暂停，让出cpu资源给其他的线程。但是和sleep()方法不同的是，它不会进入到阻塞状态，而是进入到就绪状态。yield()方法只是让当前线程暂停一下，重新进入就绪的线程池中，让系统的线程调度器重新调度器重新调度一次，完全可能出现这样的情况：当某个线程调用yield()方法之后，线程调度器又将其调度出来重新进入到运行状态执行。

实际上，当某个线程调用了yield()方法暂停之后，优先级与当前线程相同，或者优先级比当前线程更高的就绪状态的线程更有可能获得执行的机会，当然，只是有可能，因为我们不可能精确的干涉cpu调度线程。

yield的用法：

public class Test1 {  
    public static void main(String[] args) throws InterruptedException {  
        new MyThread("低级", 1).start();  
        new MyThread("中级", 5).start();  
        new MyThread("高级", 10).start();  
    }  
}  
  
class MyThread extends Thread {  
    public MyThread(String name, int pro) {  
        // 设置线程的名称  
        super(name);
        // 设置优先级 
        this.setPriority(pro); 
    }  
  
    @Override  
    public void run() {  
        for (int i = 0; i < 30; i++) {  
            System.out.println(this.getName() + "线程第" + i + "次执行！");  
            if (i % 5 == 0)  
                Thread.yield();  
        }  
    }  
}

关于sleep()方法和yield()方的区别如下：

①、sleep方法暂停当前线程后，会进入阻塞状态，只有当睡眠时间到了，才会转入就绪状态。而yield方法调用后，是直接进入就绪状态，所以有可能刚进入就绪状态，又被调度到运行状态。

②、sleep方法声明抛出了InterruptedException，所以调用sleep方法的时候要捕获该异常，或者显示声明抛出该异常。而yield方法则没有声明抛出任务异常。

③、sleep方法比yield方法有更好的可移植性，通常不要依靠yield方法来控制并发线程的执行。

3、线程合并——join

       线程的合并的含义就是将几个并行线程的线程合并为一个单线程执行，应用场景是当一个线程必须等待另一个线程执行完毕才能执行时，Thread类提供了join方法来完成这个功能，注意，它不是静态方法。
从上面的方法的列表可以看到，它有3个重载的方法：
void join()    把当前线程加到该线程后面，等待该线程终止。
void join(long millis)   当前线程等待该线程终止的时间最长为 millis 毫秒。如果在millis时间内，该线程没有执行完，那么当前线程进入就绪状态，重新等待cpu调度
void join(long millis,int nanos)    等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。如果在这段时间内，该线程没有执行完，那么当前线程进入就绪状态，重新等待cpu调度

例子：

public class TestThread {  
    public static void main(String[] args) throws InterruptedException {  
        MyThread thread=new MyThread();  
        thread.start();  
        //将主线程加入到子线程后面，不过如果子线程在1毫秒时间内没执行完，则主线程便不再等待它执行完，进入就绪状态，等待cpu调度 
        thread.join(1); 
        for(int i=0;i<30;i++){  
            System.out.println(Thread.currentThread().getName() + "线程第" + i + "次执行！");  
        }  
    }  
}  
  
class MyThread extends Thread {  
    @Override  
    public void run() {  
        for (int i = 0; i < 1000; i++) {  
            System.out.println(this.getName() + "线程第" + i + "次执行！");  
        }  
    }  
}

4、线程的优先级

每个线程执行时都有一个优先级的属性，优先级高的线程可以获得较多的执行机会，而优先级低的线程则获得较少的执行机会。与线程休眠类似，线程的优先级仍然无法保障线程的执行次序。只不过，优先级高的线程获取CPU资源的概率较大，优先级低的也并非没机会执行。

每个线程默认的优先级都与创建它的父线程具有相同的优先级，在默认情况下，main线程具有普通优先级。Thread类提供了setPriority(int newPriority)和getPriority()方法来设置和返回一个指定线程的优先级，其中setPriority方法的参数是一个整数，范围是1~·0之间，也可以使用Thread类提供的三个静态常量：

MAX_PRIORITY =10

NORM_PRIORITY =5

MIN_PRIORITY =1

public class TestThread {  
    public static void main(String[] args) throws InterruptedException {  
        new MyThread("高级", 10).start();  
        new MyThread("低级", 1).start();  
    }  
}  
  
class MyThread extends Thread {  
    public MyThread(String name,int pro) {  
        super(name);
        //设置线程的优先级 
        setPriority(pro); 
    }  
    @Override  
    public void run() {  
        for (int i = 0; i < 100; i++) {  
            System.out.println(this.getName() + "线程第" + i + "次执行！");  
        }  
    }  
}

从结果可以看到，一般情况下，高级线程会优先执行完毕。

注意一点：虽然Java提供了10个优先级别，但这些优先级别需要操作系统的支持。不同的操作系统的优先级并不相同，而且也不能很好的和Java的10个优先级别对应。所以我们应该使用MAX_PRIORITY、MIN_PRIORITY和NORM_PRIORITY三个静态常量来设定优先级，这样才能保证程序最好的可移植性。

5、守护线程

守护线程与普通线程写法上基本么啥区别，调用线程对象的方法setDaemon(true)，则可以将其设置为守护线程。

守护线程使用的情况较少，但并非无用，举例来说，JVM的垃圾回收、内存管理等线程都是守护线程。还有就是在做数据库应用时候，使用的数据库连接池，连接池本身也包含着很多后台线程，监控连接个数、超时时间、状态等等。

setDaemon方法的详细说明：
public final void setDaemon(boolean on)将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。
该方法必须在启动线程前调用。该方法首先调用该线程的 checkAccess 方法，且不带任何参数。这可能抛出 SecurityException（在当前线程中）。
  参数：   on - 如果为 true，则将该线程标记为守护线程。
  抛出：   IllegalThreadStateException - 如果该线程处于活动状态。 SecurityException - 如果当前线程无法修改该线程。

package xin.sunzy.jdk.thread.base;

/**
 * Java线程：线程的调度-守护线程
 *
 * @author Ginkgo
 */
public class TestDaemon {
    public static void main(String[] args) {
        Thread t1 = new MyCommon();
        Thread t2 = new MyDaemon();
        //设置为守护线程
        t2.setDaemon(true);
        t2.start();
        t1.start();
    }
}

class MyCommon extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("线程1第" + i + "次执行！");
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class MyDaemon extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 9999999; i++) {
            System.out.println("后台线程第" + i + "次执行！");
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

从上面的执行结果可以看出，前台线程执行完毕的，守护线程还没有执行完毕就退出了。实际上，JRE判断程序是否执行结束的标准是所有的前台执线程行完毕了，而不管守护线程的状态，因此，在使用守护线程时候一定要注意这个问题。

守护线程的用途：

守护线程通常用于执行一些后台作业，例如在你的应用程序运行时播放背景音乐，在文字编辑器里做自动语法检查、自动保存等功能。Java的垃圾回收也是一个守护线程。守护线的好处就是你不需要关心它的结束问题。例如你在你的应用程序运行的时候希望播放背景音乐，如果将这个播放背景音乐的线程设定为非守护线程，那么在用户请求退出的时候，不仅要退出主线程，还要通知播放背景音乐的线程退出，如果设定为守护线程则不需要了。

6、如何结束一个线程

如何正确地结束一个线程，这一个面试中的重灾区问题，Thread.stop()、Thread.suspend、Thread.resume、Runtime.runFinalizersOnExit这些终止线程运行的方法已经被废弃了，使用它们是极端不安全的！想要安全有效的结束一个线程，可以使用下面的方法。

1、正常执行完run方法，然后结束掉

2、控制循环条件和判断条件的标识符来结束掉线程

比如说run方法这样写：


class MyThread1 extends Thread {

    int i = 0;

    @Override
    public void run() {
        while (true) {
            if (i == 10) {
                break;
            }
            i++;
            System.out.println(i);
        }
    }
}

class MyThread2 extends Thread {

    int i = 0;
    boolean next = true;

    @Override
    public void run() {
        while (next) {
            if (i == 10) {
                next = false;
            }
            i++;
            System.out.println(i);
        }
    }
}

class MyThread3 extends Thread {
    int i = 0;

    @Override
    public void run() {
        while (true) {
            if (i == 10) {
                return;
            }
            i++;
            System.out.println(i);
        }
    }
}

只要保证在一定的情况下，run方法能够执行完毕即可。而不是while(true)死循环。

3、使用interrupt结束一个线程

使用第2种方法的标识符结束一个线程，是一个不错的方法，但是如果，该线程是处于sleep、wait、join的状态的时候，while循环就不会执行，那么我们的标识符就无用武之地了，当然也不能再通过它来结束处于这3种状态的线程了。可以使用interrupt这个巧妙的方式结束掉这个线程。

我们看看sleep、wait、join方法的声明：

public final void wait() throws InterruptedException  
public static native void sleep(long millis) throws InterruptedException  
public final void join() throws InterruptedException

这三者有一个共同点，都抛出了一个InterruptedException的异常。
在什么时候会产生这样一个异常呢？

每个Thread都有一个中断状状态，默认为false。可以通过Thread对象的isInterrupted()方法来判断该线程的中断状态。可以通过Thread对象的interrupt()方法将中断状态设置为true。

当一个线程处于sleep、wait、join这三种状态之一的时候，如果此时他的中断状态为true，那么它就会抛出一个InterruptedException的异常，并将中断状态重新设置为false。

看下面的简单的例子：

package xin.sunzy.jdk.thread.base;

/**
 * 线程中断
 *
 * @author Ginkgo
 */
public class TestInterrupt {
    public static void main(String[] args) throws InterruptedException {
        MyThread thread = new MyThread();
        thread.start();
    }
}

class MyThread extends Thread {
    int i = 1;

    @Override
    public void run() {
        while (true) {
            System.out.println(i);
            System.out.println(this.isInterrupted());
            try {
                System.out.println("我马上去sleep了");
                Thread.sleep(2000);
                this.interrupt();
            } catch (InterruptedException e) {
                System.out.println("异常捕获了" + this.isInterrupted());
                return;
            }
            i++;
        }
    }
}

可以看到，首先执行第一次while循环，在第一次循环中，睡眠2秒，然后将中断状态设置为true。当进入到第二次循环的时候，中断状态就是第一次设置的true，当它再次进入sleep的时候，马上就抛出了InterruptedException异常，然后被我们捕获了。然后中断状态又被重新自动设置为false了（从最后一条输出可以看出来）。

所以，我们可以使用interrupt方法结束一个线程。具体使用如下：

package xin.sunzy.jdk.thread.base;

/**
 * 线程中断
 *
 * @author Ginkgo
 * @since v1.0.0
 */
public class TestInterrupt1 {

    public static void main(String[] args) throws InterruptedException {
        MyThread5 thread = new MyThread5();
        thread.start();
        //主线程sleep3秒后对子线程执行中断
        Thread.sleep(3000);
        thread.interrupt();
    }
}

class MyThread5 extends Thread {
    int i = 0;

    @Override
    public void run() {
        while (true) {
            System.out.println(i);
            try {
                Thread.sleep(999);
            } catch (InterruptedException e) {
                System.out.println("中断异常被捕获了");
                return;
            }
            i++;
        }
    }
}