Thread 类的基本用法、Java 线程的几种状态

在Java中，Thread类是多线程编程的核心。

线程创建 (Thread Creation)

• 创建线程主要有两种逻辑：继承Thread类或实现Runnable接口。
  
  
  
  • 方式1：继承 Thread 类，重写run()
    
  
  

1. // 自定义线程类继承Thread
2. class MyThread extends Thread {
3.     // 重写run()，定义线程执行逻辑
4.     @Override
5.     public void run() {
6.         System.out.println("子线程执行：" + Thread.currentThread().getName());
7.     }
8. }
10. // 使用
11. public class Demo {
12.     public static void main(String[] args) {
13.         MyThread t = new MyThread();
14.         t.start(); // 3. 调用start()启动线程（不能直接调用run()）
15.     }
16. }

复制代码

• 方式2：实现Runnable接口，传给Thread
  

1. // 实现Runnable接口
2. class MyRunnable implements Runnable {
3.     @Override
4.     public void run() {
5.         System.out.println("子线程执行：" + Thread.currentThread().getName());
6.     }
7. }
9. // 使用
10. public class Demo {
11.     public static void main(String[] args) {
12.         // 把Runnable实例传给Thread
13.         Thread t = new Thread(new MyRunnable());
14.         t.start(); // 启动线程
15.     }
16. }

复制代码

线程中断 (Thread Interruption)

• 线程中断不是强制停止线程，而是一种协作机制，即给线程发一个“请停止”的信号。
  
• void interrupt()：标记线程为 “中断状态”
  
• boolean isInterrupted()：判断线程是否处于中断状态
  
• 若线程在sleep/wait/join时被中断，会抛出InterruptedException，且中断状态会被清除
  

1. Thread t = new Thread(() -> {
2.     while (!Thread.currentThread().isInterrupted()) { // 检测中断状态
3.         System.out.println("线程运行中...");
4.         try {
5.             Thread.sleep(1000);
6.         } catch (InterruptedException e) {
7.             // 捕获中断异常后，中断状态会被清除，需手动终止循环
8.             System.out.println("线程被中断");
9.             Thread.currentThread().interrupt(); // 重新标记中断（可选）
10.             break;
11.         }
12.     }
13. });
14. t.start();
15. // 主线程1秒后中断子线程
16. Thread.sleep(1000);
17. t.interrupt();

复制代码

线程等待 (Thread Join)

• 有时主线程需要等待子线程执行完毕后再继续执行，这时可以使用join()。
  
• t.join()：当前线程会进入阻塞状态，直到线程t执行结束。
  
• 带参数的 join(long millis)：设置最大等待时间，如果超时线程还没结束，当前线程就不再等待。
  

1. Thread t = new Thread(() -> {
2.     System.out.println("子线程开始执行");
3.     try { Thread.sleep(2000); } catch (InterruptedException e) {}
4.     System.out.println("子线程执行完毕");
5. });
6. t.start();
8. // 主线程等待t执行完（最多等3秒）
9. t.join(3000);
10. System.out.println("主线程继续执行");

复制代码

线程休眠 (Thread Sleep)

• static void sleep(long millis)：让当前线程暂停指定时间（不会释放锁），抛出InterruptedException
  

1. System.out.println("开始休眠");
2. try {
3.     Thread.sleep(2000); // 当前线程休眠2秒
4. } catch (InterruptedException e) {
5.     e.printStackTrace();
6. }
7. System.out.println("休眠结束");

复制代码

获取线程实例 (Get Current Instance)

• 在编写通用代码（尤其是 Runnable 中）时，常需要知道是谁在运行。
  
• Thread.currentThread()：返回代码当前正在执行的那个线程对象的引用。
  
• 常用操作：获取线程 ID (getId())、获取线程名称 (getName()) 等。
  

1. // 获取当前线程（这里是main线程）
2. Thread mainThread = Thread.currentThread();
3. System.out.println("当前线程名：" + mainThread.getName()); // 输出"main"
5. // 子线程实例
6. Thread t = new Thread(() -> {
7.     Thread current = Thread.currentThread();
8.     System.out.println("子线程名：" + current.getName()); // 输出"Thread-0"
9. });
10. t.start();

复制代码

Java线程的几种状态

线程状态一共有几种？

• Java线程共有6种状态：
  
  
  
  • NEW (新建)
    
  • RUNNABLE (可运行)
    
  • BLOCKED (阻塞)
    
  • WAITING (等待)
    
  • TIMED_WAITING (超时等待)
    
  • TERMINATED (终止)
    
  
  

每种状态的含义与切换条件

• NEW (新建)
  

• 含义：创建了线程对象（new Thread()），但尚未调用 start() 方法。
  
• 切换：调用 start() 方法后，进入 RUNNABLE 状态。
  

• RUNNABLE (可运行)
  

• 含义：Java 将操作系统中的“就绪（Ready）”和“运行中（Running）”两种状态统称为 RUNNABLE。处于该状态的线程可能正在 CPU 上执行，也可能正在等待操作系统分配时间片。
  
• 切换：
  
  
  
  • 就绪 -> 运行：获得 CPU 时间片。
    
  • 运行 -> 就绪：CPU 时间片用完，或主动调用 Thread.yield()。
    
  
  

• BLOCKED (阻塞)
  

• 含义：线程正在等待获取一个排他锁（如进入synchronized 代码块/方法），但该锁目前被其他线程持有。
  
• 切换：
  
  
  
  • RUNNABLE -> BLOCKED：尝试进入 synchronized 区域失败。
    
  • BLOCKED -> RUNNABLE：其他线程释放锁，当前线程成功竞争到锁。
    
  
  

• WAITING (等待)
  

• 含义：线程处于无限期的等待状态，不会被分配 CPU 时间，必须等待其他线程显式地唤醒。
  
• 切换：
  
  
  
  • RUNNABLE -> WAITING：调用 Object.wait()（不带参数）、Thread.join()（不带参数）或 LockSupport.park()。
    
  • WAITING -> RUNNABLE：其他线程调用 Object.notify()、notifyAll() 或 LockSupport.unpark()。
    
  
  

• TIMED_WAITING (超时等待)
  

• 含义：与 WAITING 类似，但在指定的时间后会自动唤醒，不需要其他线程显式唤醒。
  
• 切换：
  
  
  
  • RUNNABLE -> TIMED_WAITING：调用 Thread.sleep(ms)、Object.wait(ms)、Thread.join(ms) 等带时间参数的方法。
    
  • TIMED_WAITING -> RUNNABLE：时间结束，或被提前唤醒（如 notify()）。
    
  
  

• TERMINATED (终止)
  

• 含义：线程已经执行完毕（run() 方法正常结束）或因异常退出了执行。
  
• 切换：线程一旦进入此状态，生命周期结束，不可再次启动（再次调用 start() 会抛出异常）。
  

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！