深入解析Java线程状态与生命周期

深入解析Java线程状态与生命周期

在Java多线程编程中，理解线程的不同状态及其转换对于构建高效、稳定的并发应用至关重要。本文将详细讲解Java线程的六种状态（NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING和TERMINATED），并通过示例代码展示每种状态的具体表现和触发条件。

1. 新建（New）

描述：线程刚刚被创建，但尚未启动。
触发条件：创建一个新的线程对象后，还没有调用start()方法。
示例：

public class ThreadTest implements Runnable{
    @Override
    public void run() {
        System.out.println("线程："+Thread.currentThread()+" 正在执行...");
    }
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new ThreadTest()); //线程 创建（NEW）状态
    }
}

2. 运行（Running)

描述：线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一方式。
触发条件：调用start()方法后，线程进入RUNNABLE状态。
示例：

public class RunnableStateExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while (true) {
                // Busy work
            }
        });
        thread.start();
        System.out.println(thread.getState()); // 输出：RUNNABLE
    }
}

3. 阻塞（Blocked)

描述：线程在等待进入一个同步块或方法，因为另一个线程已经持有了该同步块或方法的锁。
触发条件：线程试图进入一个被其他线程持有的同步锁时。
示例：

public class BlockedExample {
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();

        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                while (true) {
                    // Keep the lock
                }
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (lock) {
                // This will not be reached
            }
        });

        t1.start();
        Thread.sleep(100); // Ensure t1 has acquired the lock
        t2.start();
        Thread.sleep(100); // Ensure t2 attempts to acquire the lock
        System.out.println(t2.getState()); // 输出：BLOCKED
    }
}

4. 等待（Waiting）

描述：线程无限期地等待另一个线程执行特定操作（如通知或中断）。
触发条件：线程调用Object.wait()、Thread.join()（不带超时参数）或LockSupport.park()方法时。
示例：

public class WaitingExample {
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();

        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        t1.start();
        Thread.sleep(100); // Ensure t1 has called wait()
        System.out.println(t1.getState()); // 输出：WAITING
    }
}

5. 超时等待（Timed-Waiting）

描述：线程在等待另一个线程执行特定操作，但有超时限制。
触发条件：线程调用带有超时参数的Thread.sleep()、Object.wait()、Thread.join()或LockSupport.parkNanos()和LockSupport.parkUntil()方法时。
示例：

public class TimedWaitingExample {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        t1.start();
        Thread.sleep(100); // Ensure t1 has called sleep()
        System.out.println(t1.getState()); // 输出：TIMED_WAITING
    }
}

6. 终止（Terminal）

描述：线程已经完成执行或因异常而终止。
触发条件：线程的run()方法执行完成或抛出未捕获的异常。
示例：

public class TerminatedExample {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            System.out.println("Thread is running");
        });

        t1.start();
        t1.join(); // Wait for t1 to finish
        System.out.println(t1.getState()); // 输出：TERMINATED
    }
}

总结

Java线程状态管理是并发编程的基础知识。通过理解线程在不同状态下的行为，可以更好地调试和优化并发程序，避免常见的并发问题如死锁、资源竞争等。Java提供了丰富的API来控制和管理线程状态，使得开发高性能、高可靠性的并发应用程序成为可能。