Java Thread 对象详解

缺乏、安全感 2024-02-19 21:54 13阅读 0赞

**目录**

1、Thread.sleep() 方法详解

2、Thread.interrupt() 方法详解

3、Thread.join() 方法详解

--------------------

Java中的Thread类是一个非常重要的类，用于创建和管理线程。下面是Thread类的一些重要方法和属性的详细解释：

（1）构造方法：Thread类提供了多个构造方法，常用的有以下两个：

*  `Thread()`: 创建一个新线程，该线程不执行任何操作。
 *  `Thread(Runnable target)`: 创建一个新线程，并指定其要执行的Runnable对象。

**（2）start() 方法：**start() 方法是启动线程的方法，它将启动一个新线程并调用run() 方法。start() 方法不能被重复调用，否则将抛出IllegalThreadStateException 异常。

**（3）run() 方法：**`run()` 方法是线程的执行体，它必须被子类覆盖。当调用`start()` 方法后，新线程会执行其`run()` 方法中的代码。

**（4）sleep() 方法：**`sleep(long millis)` 方法会使当前线程睡眠指定的毫秒数，让出CPU的使用权。当睡眠结束后，线程将重新回到可运行状态。

（5）yield() 方法：`yield()` 方法是暂停当前线程的执行，让出CPU的使用权，让线程调度器将执行机会转移给其他线程。但是，调度器并不保证一定会转移执行机会。

**（6）join() 方法：**`join()` 方法会等待调用它的线程结束，才会继续执行当前线程。如果传入了一个超时参数，它会等待一段时间后返回。

**（7）interrupt() 方法：**`interrupt()` 方法会中断当前线程。当该方法被调用时，线程将收到一个中断信号，可以在自己的`run()` 方法中检测到这个信号并执行相应的操作。// 打标记操作

**（8）isInterrupted() 方法：**`isInterrupted()` 方法用于检测当前线程是否被中断。如果线程被中断，它将返回true；否则，返回false。// 检测操作

（9）getName() 和 setName() 方法：getName() 方法返回线程的名称，setName() 方法用于设置线程的名称。

除此之外，Thread类还有一些其他的方法和属性，例如`getId()` 方法返回线程的唯一标识符，`isAlive()` 方法用于检测线程是否还存活等等。这些方法和属性可以帮助我们更好地了解和管理线程。

#### 1、Thread.sleep() 方法详解 ####

在Java中，Thread.sleep()方法用于使当前执行的线程暂停指定的时间（以毫秒为单位），然后转回到可运行状态，等待CPU的调度。该方法可以用于模拟线程执行中的延迟，或者在需要等待某些操作完成之后再继续执行时进行暂停。// sleep()不释放锁

Thread.sleep()方法有两种重载形式：

*  static void sleep(long millis)：使当前线程睡眠指定的毫秒数。
 *  static void sleep(long millis, int nanos)：使当前线程睡眠指定的毫秒数和纳秒数。

在调用Thread.sleep()方法时，可能会抛出InterruptedException异常，表示当前线程在睡眠期间被中断了。通常情况下，中断线程是通过调用该线程的interrupt()方法实现的，这会导致Thread.sleep()方法抛出InterruptedException异常并返回。// sleep()可被中断，并清除中断状态

需要注意的是，虽然Thread.sleep()方法可以用于暂停线程的执行，但不建议过度依赖它来控制程序的执行流程，因为它可能会导致不可预期的行为。

Thread.sleep()方法可以用来使当前线程休眠一段时间，具体使用示例如下：

public class SleepExample {
        public static void main(String[] args) {
            System.out.println("开始执行...");
            try {
                // 使当前线程休眠 3 秒钟
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("执行结束。");
        }
    }

在上述示例中，我们通过Thread.sleep()方法使当前线程休眠 3 秒钟，然后输出“执行结束。”的信息。需要注意的是，由于Thread.sleep()方法可能会抛出InterruptedException异常，因此在使用时应该进行异常处理。此外，需要注意Thread.sleep()方法只会让当前线程休眠，而不会影响其他线程的执行。

#### 2、Thread.interrupt() 方法详解 ####

在 Java 中，可以使用 `Thread.interrupt()` 方法中断一个正在运行的线程。当一个线程在运行过程中被中断后，它会收到一个中断信号，可以根据这个信号来进行相应的处理。下面是 `Thread.interrupt()` 方法的详细解释。

**方法说明**

Thread.interrupt() 方法用于中断线程。当线程被中断时，它的中断状态将被设置为 true。如果该线程正在等待某个对象锁、等待 Thread.sleep() 返回或等待 Thread.join() 返回时，它将会立即抛出一个 InterruptedException 异常，并清除中断状态。// 立即抛出中断异常的场景（线程在等待）

如果线程没有被阻塞，那么 Thread.interrupt() 只会将该线程的中断状态设置为 true，并不会停止线程的运行。

**使用示例**

下面是一个简单的使用 `Thread.interrupt()` 方法的示例：

public class ExampleThread extends Thread {
        public void run() {
            while(!Thread.currentThread().isInterrupted()) {
                System.out.println("Thread is running");
            }
            System.out.println("Thread has been interrupted");
        }
    
        public static void main(String[] args) throws InterruptedException {
            ExampleThread thread = new ExampleThread();
            thread.start();
            Thread.sleep(5000);
            thread.interrupt();
        }
    }

在上面的示例中，创建了一个 `ExampleThread` 类，它继承自 `Thread` 类。在 `run()` 方法中，当线程的中断状态为 `false` 时，会一直输出 "Thread is running"。当线程的中断状态变为 `true` 时，会输出 "Thread has been interrupted"。

在 `main()` 方法中，先创建了一个 `ExampleThread` 线程并启动它，然后主线程睡眠了 5 秒钟，最后调用了 `thread.interrupt()` 方法，将该线程的中断状态设置为 `true`。当 `ExampleThread` 线程被中断后，它会输出 "Thread has been interrupted"。

**isInterrupted() 和 interrupted() 的区别**

在Java中，线程有两个方法可以用于检查它是否被中断：`isInterrupted()`和`interrupted()`。这两个方法有以下区别：

*  **`isInterrupted()`**方法是**实例方法**，它用于检查当前线程是否已被中断，并返回一个布尔值。该方法不会影响中断状态，即不会清除中断标志。因此，如果线程被中断了，然后再调用`isInterrupted()`方法，它将返回`true`，除非在此期间调用了`interrupted()`方法清除了中断状态。
 *  **`interrupted()`**方法是一个**静态方法**，它用于检查当前线程是否已被中断，并返回一个布尔值。与`isInterrupted()`方法不同，如果线程被中断了，该方法将清除中断状态，并返回`true`。因此，如果线程被中断了，连续调用多次`interrupted()`方法，只有第一次会返回`true`，后面的都会返回`false`。

总结：`isInterrupted()` 方法只是检测当前线程是否被中断，并不会清除线程的中断状态。如果需要清除中断状态，可以调用 `Thread.interrupted()` 方法。

#### 3、Thread.join() 方法详解 ####

在Java多线程编程中，当一个线程需要等待另一个线程结束后才能继续执行时，可以使用`join()`方法。`join()`方法是一个非静态方法，可以在一个线程实例上调用。该方法会使当前线程阻塞，直到目标线程结束才会继续执行当前线程。下面对`join()`方法进行详细介绍：

join()方法有以下两种重载形式：

*  `public final void join() throws InterruptedException`

该方法会等待调用该方法的线程结束后再继续执行。如果目标线程在调用该方法前已经结束，则该方法会立即返回。如果目标线程在调用该方法时还在运行，则当前线程会被阻塞，直到目标线程结束后才会继续执行。

*  `public final synchronized void join(long millis) throws InterruptedException`

该方法会等待指定时间（单位为毫秒）内目标线程结束后再继续执行，其余同上。

下面是一个使用`join()`方法的示例：

public class JoinDemo {
        public static void main(String[] args) throws InterruptedException {
            Thread t1 = new Thread(() -> {
                for (int i = 0; i < 5; i++) {
                    System.out.println("Thread-1: " + i);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
    
            Thread t2 = new Thread(() -> {
                for (int i = 0; i < 5; i++) {
                    System.out.println("Thread-2: " + i);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
    
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            System.out.println("Main thread exits.");
        }
    }

上述示例中创建了两个线程t1和t2，它们分别打印数字1到5。在主线程中，分别调用t1.join()和t2.join()方法，使主线程在t1和t2线程结束后才能继续执行。在输出完数字后，主线程输出一条结束信息。运行该程序，可以得到以下输出：

Thread-1: 0
    Thread-2: 0
    Thread-1: 1
    Thread-2: 1
    Thread-1: 2
    Thread-2: 2
    Thread-2: 3
    Thread-1: 3
    Thread-2: 4
    Thread-1: 4
    Main thread exits.

有关Thread类的更多信息，请参考[Thread类的API][Thread_API]。

[Thread_API]: https://docs.oracle.com/en/java/javase/20/docs/api/java.base/java/lang/Thread.html