一文搞懂Java的线程生命周期

灬沙师弟

发布于 2023-09-06 08:19:08

2440

发布于 2023-09-06 08:19:08

文章被收录于专栏：Java面试教程

摘要

Java的多线程机制为开发者提供了充分利用多核处理器的能力，但同时也带来了线程安全和同步等问题。了解Java线程的生命周期对于正确管理和调试多线程程序至关重要。

1. 引言

在当今高并发的计算环境中，多线程编程成为Java开发中的常见需求。Java提供了丰富的多线程支持，但同时也带来了线程安全和同步问题。了解Java线程的生命周期是深入掌握多线程编程的关键，本文将系统介绍Java线程的完整生命周期。

2. 线程的生命周期

Java线程的生命周期可分为以下几个阶段：

新建（New）：线程对象被创建，但尚未启动。此时线程状态为NEW。

可运行（Runnable）：调用线程的start()方法后，线程进入可运行状态，等待获取CPU执行时间片。线程调度器会从可运行的线程中选择一个来执行。此时线程状态为RUNNABLE。

运行（Running）：获取到CPU执行时间片后，线程进入运行状态，执行线程的run()方法中的代码。此时线程状态为RUNNING。

阻塞（Blocked）：线程可能会由于某种原因而阻塞，比如等待I/O操作或等待获取某个锁。在这种情况下，线程的状态为BLOCKED。

等待（Waiting）：线程调用wait()方法，或者join()方法，或者LockSupport.park()方法，使线程进入等待状态。此时线程状态为WAITING。

超时等待（Timed Waiting）：线程调用带有超时参数的sleep()方法或wait()方法，使线程进入具有超时时间的等待状态。此时线程状态为TIMED_WAITING。

终止（Terminated）：线程执行完run()方法的代码，或者因异常而提前结束。线程的状态变为TERMINATED。

3. 代码示例

让我们通过一个简单的示例来演示Java线程的生命周期：

public class ThreadLifecycleExample {

    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        System.out.println("New State: " + thread.getState());

        thread.start();
        System.out.println("Runnable State: " + thread.getState());

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("After Sleep - State: " + thread.getState());
    }
}

class MyRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println("Running - State: " + Thread.currentThread().getState());

        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("After Sleep - State: " + Thread.currentThread().getState());
    }
}

在这个示例中，我们创建了一个MyRunnable类，它实现了Runnable接口，并在run()方法中定义了线程的执行逻辑。

在main方法中，我们创建了一个新线程thread，并输出其初始状态为"New"。然后，我们调用start()方法启动线程，输出线程状态为"Runnable"，表示线程已经准备好并等待获取CPU时间片。

接着，我们让主线程睡眠1秒钟，让新线程有足够的时间去执行。在新线程的run()方法中，我们也让线程睡眠500毫秒，模拟线程的运行。

最后，我们输出线程状态，可以看到新线程先是运行状态，然后在run()方法中调用了sleep()方法后进入了超时等待状态，最终线程执行完毕后进入终止状态。

4. 处理并发问题

在多线程编程中，常常会遇到线程安全和同步问题。多个线程同时访问共享资源可能导致数据不一致，或者多个线程竞争同一个锁可能导致死锁等问题。为了处理这些并发问题，我们可以采用以下方法：

4.1 使用synchronized关键字

synchronized关键字用于在方法或代码块级别上加锁，确保同一时间只有一个线程访问共享资源，从而避免数据竞争和线程安全问题。

class Counter {
    private int count = 0;

    // 使用synchronized关键字确保线程安全
    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

4.2 使用Lock接口

Java提供了更灵活的Lock接口，可以使用ReentrantLock或者ReadWriteLock来代替synchronized关键字。Lock接口允许更细粒度地控制锁，例如设置超时时间、可中断等特性。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class Counter {
    private int count = 0;
    private Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

4.3 使用volatile关键字

volatile关键字用于保证变量的可见性，确保线程在读取变量时可以获得最新的值。当一个变量被声明为volatile时，每次访问它时都会从主内存中读取，而不是使用线程的本地缓存。

class MyThread extends Thread {
    private volatile boolean running = true;

    public void stopRunning() {
        running = false;
    }

    @Override
    public void run() {
        while (running) {
            // 线程执行的逻辑
        }
    }
}

4.4 使用并发容器

Java提供了一系列线程安全的并发容器，如ConcurrentHashMap、ConcurrentLinkedQueue等，用于处理多线程环境下的数据共享。这些容器是通过内部使用并发技术实现线程安全的，因此无需额外的同步措施。

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentExample {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

        map.put("key1", 1);
        map.put("key2", 2);

        // 线程安全的遍历操作
        map.forEach((key, value) -> System.out.println(key + ": " + value));
    }
}