Java线程启动异常解析：避免 IllegalThreadStateException-小易智趣

摘要

在Java编程语言中，尝试多次启动同一个线程会导致特定的后果。根据Java的线程管理规范，线程一旦启动后，便不允许再次启动。如果尝试对同一个线程进行第二次启动，Java运行时环境会抛出一个名为IllegalThreadStateException的异常。这种异常属于运行时异常，它表明线程处于一个非法的状态，即尝试执行了一个不被允许的操作。大多数程序员对此存在误解，认为线程可以被重复启动，但实际上这种行为是不被允许的，并且会导致程序出现异常。

关键词

Java线程, 启动异常, 线程管理, 非法状态, 运行时

一、Java线程的启动原理

1.1 线程的创建与启动

在Java编程语言中，线程的创建与启动是一个基础但至关重要的概念。线程是程序执行的基本单位，通过多线程技术，可以实现并发处理，提高程序的性能和响应速度。创建线程通常有三种方式：继承Thread类、实现Runnable接口以及使用ExecutorService。

继承`Thread`类

最直接的方式是通过继承Thread类来创建线程。具体步骤如下：

定义子类：创建一个新的类，继承自Thread类。
重写run方法：在子类中重写run方法，该方法包含线程要执行的代码。
创建实例：创建子类的实例。
启动线程：调用实例的start方法，启动线程。

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程正在运行");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

实现`Runnable`接口

另一种常见的方法是实现Runnable接口。这种方式更加灵活，因为它避免了单继承的限制。

定义类：创建一个新的类，实现Runnable接口。
实现run方法：在类中实现run方法。
创建线程实例：创建Thread类的实例，并将Runnable对象传递给构造函数。
启动线程：调用Thread实例的start方法。

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("线程正在运行");
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}

使用`ExecutorService`

对于更复杂的多线程应用，推荐使用ExecutorService。它可以管理和调度线程池，提高资源利用率。

创建ExecutorService：使用Executors工厂方法创建ExecutorService。
提交任务：使用submit或execute方法提交任务。
关闭服务：使用shutdown方法关闭ExecutorService。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        executorService.submit(new MyRunnable());
        executorService.shutdown();
    }
}

1.2 线程的启动过程详解

线程的启动过程涉及多个步骤，每个步骤都有其特定的作用。理解这些步骤有助于更好地掌握线程管理的细节。

创建线程对象

首先，需要创建一个线程对象。这可以通过继承Thread类或实现Runnable接口来完成。创建线程对象时，不会立即开始执行线程的代码，只是为线程分配了必要的资源。

调用`start`方法

调用线程对象的start方法是启动线程的关键步骤。start方法会执行以下操作：

检查线程状态：确保线程尚未启动。如果线程已经启动，调用start方法会抛出IllegalThreadStateException异常。
创建系统级线程：在操作系统层面创建一个新的线程。
调用run方法：新创建的系统级线程会调用线程对象的run方法，开始执行线程的代码。

`run`方法的执行

run方法是线程的核心，包含了线程要执行的具体任务。当run方法执行完毕，线程会进入终止状态。如果run方法中抛出未捕获的异常，线程也会终止。

线程的状态转换

线程在其生命周期中会经历多种状态，包括新建、就绪、运行、阻塞和终止。这些状态之间的转换由线程调度器管理。

新建：线程对象已创建，但尚未调用start方法。
就绪：线程已调用start方法，等待CPU调度。
运行：线程正在执行run方法中的代码。
阻塞：线程因某种原因暂停执行，如等待I/O操作完成。
终止：线程执行完毕或因异常终止。

小结

正确理解和使用线程的创建与启动过程，是编写高效、可靠的多线程程序的基础。通过遵循Java的线程管理规范，避免重复启动线程等非法操作，可以有效防止程序出现异常，提高程序的稳定性和性能。

二、IllegalThreadStateException异常分析

2.1 异常的产生原因

在Java编程语言中，尝试多次启动同一个线程会导致IllegalThreadStateException异常的产生。这一异常的根源在于Java线程管理规范的严格性。根据规范，线程一旦启动后，其状态将从“新建”转变为“运行”，并且不能再被重新启动。如果尝试对已经启动的线程再次调用start方法，Java运行时环境会检测到这一非法操作，并抛出IllegalThreadStateException异常。

这种异常的产生原因主要有以下几点：

线程状态的不可逆性：线程的状态转换是不可逆的。一旦线程进入“运行”状态，它将无法回到“新建”状态。因此，再次调用start方法是无效且非法的。
资源管理的复杂性：线程的启动涉及到操作系统级别的资源分配，如内存、处理器时间片等。如果允许线程多次启动，将会导致资源管理的混乱，增加系统的复杂性和不稳定性。
设计上的考虑：Java的设计者为了保证线程的安全性和可靠性，明确禁止了线程的重复启动。这一设计决策有助于防止开发者在多线程编程中出现常见的错误，如死锁、竞态条件等。

2.2 异常的捕获与处理

面对IllegalThreadStateException异常，开发者需要采取适当的措施来捕获和处理这一异常，以确保程序的健壮性和稳定性。以下是一些常见的处理方法：

异常捕获：使用try-catch语句块来捕获IllegalThreadStateException异常。通过捕获异常，可以避免程序因未处理的异常而崩溃。

try {
    myThread.start();
} catch (IllegalThreadStateException e) {
    System.err.println("线程已经启动，不能再次启动: " + e.getMessage());
}

状态检查：在调用start方法之前，先检查线程的状态。如果线程已经启动，则不再调用start方法。这可以通过检查线程的isAlive方法来实现。
```
if (!myThread.isAlive()) {
    myThread.start();
} else {
    System.err.println("线程已经启动，不能再次启动");
}
```

日志记录：在捕获异常后，记录详细的日志信息，以便于后续的调试和问题排查。使用日志框架（如Log4j、SLF4J等）可以帮助开发者更好地管理日志。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Main {
    private static final Logger logger = LoggerFactory.getLogger(Main.class);

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        try {
            myThread.start();
            myThread.start(); // 再次启动线程
        } catch (IllegalThreadStateException e) {
            logger.error("线程已经启动，不能再次启动: {}", e.getMessage());
        }
    }
}

异常处理策略：根据具体的业务需求，制定合理的异常处理策略。例如，可以在捕获异常后，重新创建一个新的线程实例并启动，或者采取其他补救措施。
```
if (!myThread.isAlive()) {
    myThread.start();
} else {
    // 重新创建一个新的线程实例
    MyThread newThread = new MyThread();
    newThread.start();
}
```

通过以上方法，开发者可以有效地捕获和处理IllegalThreadStateException异常，确保程序在多线程环境下稳定运行。理解并遵循Java的线程管理规范，是编写高质量多线程程序的重要前提。

三、线程启动异常的预防策略

3.1 正确使用线程启动方法

在Java编程中，正确使用线程启动方法是确保程序稳定运行的关键。根据Java的线程管理规范，线程的启动必须遵循一定的规则，否则可能会引发IllegalThreadStateException异常。为了防止这种情况的发生，开发者需要了解并遵守以下几点：

避免重复启动线程：线程一旦启动，其状态将从“新建”转变为“运行”，此时再次调用start方法将导致异常。因此，在启动线程前，务必检查线程是否已经启动。
```
if (!myThread.isAlive()) {
    myThread.start();
} else {
    System.err.println("线程已经启动，不能再次启动");
}
```
合理选择线程创建方式：Java提供了多种创建线程的方法，包括继承Thread类、实现Runnable接口以及使用ExecutorService。每种方法都有其适用场景，开发者应根据实际需求选择合适的方式。
- 继承Thread类：适用于简单的多线程应用场景，代码直观易懂。
- 实现Runnable接口：更加灵活，避免了单继承的限制，适合复杂的多线程任务。
- 使用ExecutorService：适用于需要管理大量线程的应用，可以有效提高资源利用率和程序性能。
确保线程安全：在多线程环境中，线程安全是一个重要问题。开发者应使用同步机制（如synchronized关键字、Lock接口等）来保护共享资源，防止数据竞争和不一致。

3.2 线程启动后的状态检查

线程启动后，其状态会从“新建”转变为“运行”。为了确保线程的正常运行，开发者需要定期检查线程的状态，并采取相应的措施。以下是一些常用的状态检查方法：

使用isAlive方法：isAlive方法用于检查线程是否仍在运行。如果线程已经启动且未终止，该方法将返回true。
```
if (myThread.isAlive()) {
    System.out.println("线程正在运行");
} else {
    System.out.println("线程已终止");
}
```
使用getState方法：getState方法返回线程的当前状态，包括新建、就绪、运行、阻塞和终止等。通过检查线程的状态，可以更详细地了解线程的运行情况。
```
Thread.State state = myThread.getState();
System.out.println("线程状态: " + state);
```
监控线程的生命周期：在多线程应用中，监控线程的生命周期是非常重要的。开发者可以使用join方法等待线程结束，确保主线程在所有子线程完成后继续执行。
```
try {
    myThread.join();
} catch (InterruptedException e) {
    System.err.println("线程被中断: " + e.getMessage());
}
```

3.3 编写健壮的线程管理代码

编写健壮的线程管理代码是确保多线程应用稳定运行的关键。以下是一些最佳实践，帮助开发者编写高质量的线程管理代码：

异常处理：在多线程环境中，异常处理尤为重要。开发者应使用try-catch语句块捕获可能的异常，并采取适当的措施进行处理。
```
try {
    myThread.start();
} catch (IllegalThreadStateException e) {
    System.err.println("线程已经启动，不能再次启动: " + e.getMessage());
}
```
资源管理：线程的启动和终止涉及到系统资源的分配和释放。开发者应确保在不再需要线程时，及时释放相关资源，避免资源泄漏。
```
myThread.interrupt();
myThread = null;
```

日志记录：在多线程应用中，日志记录是调试和问题排查的重要手段。使用日志框架（如Log4j、SLF4J等）可以帮助开发者更好地管理日志信息。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Main {
    private static final Logger logger = LoggerFactory.getLogger(Main.class);

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        try {
            myThread.start();
        } catch (IllegalThreadStateException e) {
            logger.error("线程已经启动，不能再次启动: {}", e.getMessage());
        }
    }
}

测试与验证：在开发过程中，应进行充分的测试和验证，确保线程管理代码的正确性和健壮性。使用单元测试和集成测试工具，可以帮助开发者发现潜在的问题并及时修复。

通过以上方法，开发者可以编写出高质量、健壮的线程管理代码，确保多线程应用的稳定运行。理解并遵循Java的线程管理规范，是编写高效、可靠多线程程序的重要前提。

四、Java线程管理的最佳实践

4.1 线程复用与线程池

在Java编程中，线程的复用和线程池的使用是提高程序性能和资源利用率的有效手段。线程池是一种预先创建并维护多个线程的机制，可以避免频繁创建和销毁线程带来的开销。通过合理使用线程池，开发者可以显著提升程序的效率和响应速度。

线程池的优势

减少资源消耗：线程的创建和销毁是一个相对昂贵的操作，特别是在高并发场景下。线程池通过复用已存在的线程，减少了这些操作的频率，从而降低了资源消耗。
提高响应速度：由于线程已经预先创建好，当有任务需要执行时，可以直接从线程池中获取一个空闲线程，减少了任务的等待时间，提高了系统的响应速度。
控制并发数量：线程池可以设置最大线程数，从而控制系统的并发度，避免因过多的线程导致系统资源耗尽，影响系统的稳定性和性能。

常见的线程池类型

Java提供了多种类型的线程池，每种类型都有其特定的用途和适用场景：

固定大小线程池：使用Executors.newFixedThreadPool(int nThreads)创建。这种线程池中的线程数量是固定的，适用于负载较重、任务量较大的场景。
缓存线程池：使用Executors.newCachedThreadPool()创建。这种线程池会根据需要创建新的线程，但在先前创建的线程可用时会重用它们，适用于执行大量短小任务的场景。
单线程线程池：使用Executors.newSingleThreadExecutor()创建。这种线程池只有一个线程，适用于需要顺序执行任务的场景。
定时线程池：使用Executors.newScheduledThreadPool(int corePoolSize)创建。这种线程池支持定时和周期性任务的执行，适用于需要定时执行任务的场景。

示例代码

以下是一个使用固定大小线程池的示例代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 10; i++) {
            int taskId = i;
            executorService.submit(() -> {
                System.out.println("任务 " + taskId + " 正在执行，由线程 " + Thread.currentThread().getName() + " 处理");
            });
        }

        executorService.shutdown();
    }
}

4.2 避免线程并发错误

在多线程编程中，线程并发错误是一个常见的问题，可能导致数据不一致、死锁、竞态条件等严重后果。为了避免这些问题，开发者需要采取一系列措施，确保线程的安全性和可靠性。

数据同步

使用synchronized关键字：synchronized关键字可以确保同一时间只有一个线程可以访问某个方法或代码块，从而避免数据竞争。

public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized void decrement() {
        count--;
    }

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

使用Lock接口：Lock接口提供了比synchronized更灵活的锁定机制，可以实现更细粒度的控制。

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

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

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

    public void decrement() {
        lock.lock();
        try {
            count--;
        } finally {
            lock.unlock();
        }
    }

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

避免死锁

按顺序加锁：在多个资源需要加锁的情况下，确保所有线程都按照相同的顺序加锁，可以有效避免死锁。

public class ResourceA {
    public synchronized void methodA(ResourceB b) {
        System.out.println("Thread " + Thread.currentThread().getName() + " entered methodA");
        b.methodB();
    }
}

public class ResourceB {
    public synchronized void methodB() {
        System.out.println("Thread " + Thread.currentThread().getName() + " entered methodB");
    }
}

public class DeadlockExample {
    public static void main(String[] args) {
        ResourceA a = new ResourceA();
        ResourceB b = new ResourceB();

        Thread t1 = new Thread(() -> a.methodA(b));
        Thread t2 = new Thread(() -> b.methodB());

        t1.start();
        t2.start();
    }
}

使用tryLock方法：tryLock方法允许线程在无法获得锁时立即返回，而不是无限期等待，从而避免死锁。

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

public class ResourceA {
    private final Lock lock = new ReentrantLock();

    public void methodA(ResourceB b) {
        lock.lock();
        try {
            System.out.println("Thread " + Thread.currentThread().getName() + " entered methodA");
            if (b.getLock().tryLock()) {
                try {
                    b.methodB();
                } finally {
                    b.getLock().unlock();
                }
            }
        } finally {
            lock.unlock();
        }
    }

    public Lock getLock() {
        return lock;
    }
}

public class ResourceB {
    private final Lock lock = new ReentrantLock();

    public void methodB() {
        lock.lock();
        try {
            System.out.println("Thread " + Thread.currentThread().getName() + " entered methodB");
        } finally {
            lock.unlock();
        }
    }

    public Lock getLock() {
        return lock;
    }
}

public class DeadlockAvoidanceExample {
    public static void main(String[] args) {
        ResourceA a = new ResourceA();
        ResourceB b = new ResourceB();

        Thread t1 = new Thread(() -> a.methodA(b));
        Thread t2 = new Thread(() -> b.methodB());

        t1.start();
        t2.start();
    }
}

通过以上方法，开发者可以有效地避免线程并发错误，确保多线程程序的稳定性和可靠性。理解并遵循Java的线程管理规范，是编写高质量多线程程序的重要前提。

五、线程启动异常的案例分享

5.1 常见错误案例分析

在Java多线程编程中，尽管Java提供了丰富的线程管理工具和规范，但许多开发者仍然会因为对线程管理的误解而犯一些常见的错误。这些错误不仅会影响程序的性能，还可能导致严重的运行时异常。以下是一些典型的错误案例及其分析。

案例一：重复启动线程

背景：某开发者在编写一个多线程应用程序时，试图在一个循环中多次启动同一个线程，以实现任务的重复执行。

代码示例：

public class RepeatStartThread {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        for (int i = 0; i < 5; i++) {
            myThread.start();
        }
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程正在运行");
    }
}

问题分析：在这个例子中，开发者试图在一个循环中多次调用start方法启动同一个线程。根据Java的线程管理规范，线程一旦启动后，其状态将从“新建”转变为“运行”，此时再次调用start方法将导致IllegalThreadStateException异常。在第一次调用start方法后，线程进入“运行”状态，后续的调用都会抛出异常。

解决方案：为了避免这种错误，开发者应该在每次启动线程前检查线程的状态，确保线程没有被启动过。如果需要重复执行任务，可以创建新的线程实例。

public class RepeatStartThread {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            MyThread myThread = new MyThread();
            myThread.start();
        }
    }
}

案例二：忽略线程状态检查

背景：某开发者在编写一个多线程应用程序时，没有在启动线程前检查线程的状态，导致在某些情况下尝试启动已经启动的线程。

代码示例：

public class NoStateCheck {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        // 模拟某些逻辑
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        myThread.start();
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程正在运行");
    }
}

问题分析：在这个例子中，开发者在第一次启动线程后，模拟了一些逻辑处理，然后再次尝试启动同一个线程。由于线程已经处于“运行”状态，第二次调用start方法会抛出IllegalThreadStateException异常。

解决方案：为了避免这种错误，开发者应该在启动线程前检查线程的状态，确保线程没有被启动过。

public class NoStateCheck {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        // 模拟某些逻辑
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (!myThread.isAlive()) {
            myThread.start();
        } else {
            System.err.println("线程已经启动，不能再次启动");
        }
    }
}

5.2 最佳实践案例分析

在Java多线程编程中，遵循最佳实践不仅可以提高程序的性能，还可以增强程序的稳定性和可靠性。以下是一些典型的最佳实践案例及其分析。

案例一：使用线程池管理线程

背景：某开发者在编写一个多线程应用程序时，使用了线程池来管理线程，以提高程序的性能和资源利用率。

代码示例：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 10; i++) {
            int taskId = i;
            executorService.submit(() -> {
                System.out.println("任务 " + taskId + " 正在执行，由线程 " + Thread.currentThread().getName() + " 处理");
            });
        }

        executorService.shutdown();
    }
}

问题分析：在这个例子中，开发者使用了固定大小的线程池来管理线程。线程池可以预先创建并维护多个线程，避免了频繁创建和销毁线程带来的开销。通过合理使用线程池，开发者可以显著提升程序的效率和响应速度。

最佳实践：使用线程池可以减少资源消耗，提高响应速度，并控制并发数量。开发者应根据实际需求选择合适的线程池类型，如固定大小线程池、缓存线程池、单线程线程池和定时线程池。

案例二：使用`synchronized`关键字确保数据同步

背景：某开发者在编写一个多线程应用程序时，使用了synchronized关键字来确保数据同步，避免数据竞争和不一致。

代码示例：

public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized void decrement() {
        count--;
    }

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

问题分析：在这个例子中，开发者使用了synchronized关键字来确保同一时间只有一个线程可以访问某个方法或代码块，从而避免数据竞争。通过这种方式，可以确保数据的一致性和安全性。

最佳实践：使用synchronized关键字可以确保数据同步，避免数据竞争。此外，开发者还可以使用Lock接口来实现更细粒度的控制，提高程序的灵活性和性能。

案例三：按顺序加锁避免死锁

背景：某开发者在编写一个多线程应用程序时，通过按顺序加锁的方式来避免死锁，确保程序的稳定性和可靠性。

代码示例：

public class ResourceA {
    public synchronized void methodA(ResourceB b) {
        System.out.println("Thread " + Thread.currentThread().getName() + " entered methodA");
        b.methodB();
    }
}

public class ResourceB {
    public synchronized void methodB() {
        System.out.println("Thread " + Thread.currentThread().getName() + " entered methodB");
    }
}

public class DeadlockAvoidanceExample {
    public static void main(String[] args) {
        ResourceA a = new ResourceA();
        ResourceB b = new ResourceB();

        Thread t1 = new Thread(() -> a.methodA(b));
        Thread t2 = new Thread(() -> b.methodB());

        t1.start();
        t2.start();
    }
}

问题分析：在这个例子中，开发者通过按顺序加锁的方式来避免死锁。所有线程都按照相同的顺序加锁，可以有效避免死锁的发生。此外，开发者还可以使用tryLock方法来避免死锁，允许线程在无法获得锁时立即返回，而不是无限期等待。

最佳实践：按顺序加锁可以有效避免死锁，确保程序的稳定性和可靠性。使用tryLock方法可以进一步提高程序的灵活性和性能，避免因无法获得锁而导致的死锁问题。

通过以上最佳实践案例，开发者可以编写出高质量、健壮的多线程程序，确保程序在高并发环境下的稳定性和性能。理解并遵循Java的线程管理规范，是编写高效、可靠多线程程序的重要前提。

六、总结

在Java编程语言中，线程的管理是一个复杂但至关重要的主题。本文详细探讨了线程的启动原理、IllegalThreadStateException异常的产生原因及处理方法，以及如何通过最佳实践预防线程启动异常。通过正确使用线程启动方法、合理选择线程创建方式、确保线程安全、定期检查线程状态和编写健壮的线程管理代码，开发者可以有效避免常见的线程管理错误，确保多线程程序的稳定性和性能。此外，使用线程池和数据同步机制，可以进一步提高程序的效率和资源利用率。遵循Java的线程管理规范，是编写高质量多线程程序的重要前提。希望本文的内容能帮助读者更好地理解和应用Java线程管理的相关知识。

Java线程启动异常解析：避免 IllegalThreadStateException

摘要

关键词

一、Java线程的启动原理

1.1 线程的创建与启动

继承Thread类

实现Runnable接口

使用ExecutorService

1.2 线程的启动过程详解

创建线程对象

调用start方法

run方法的执行

线程的状态转换

小结

二、IllegalThreadStateException异常分析

2.1 异常的产生原因

2.2 异常的捕获与处理

三、线程启动异常的预防策略

3.1 正确使用线程启动方法

3.2 线程启动后的状态检查

3.3 编写健壮的线程管理代码

四、Java线程管理的最佳实践

4.1 线程复用与线程池

线程池的优势

常见的线程池类型

示例代码

4.2 避免线程并发错误

数据同步

避免死锁

五、线程启动异常的案例分享

5.1 常见错误案例分析

案例一：重复启动线程

案例二：忽略线程状态检查

5.2 最佳实践案例分析

案例一：使用线程池管理线程

案例二：使用synchronized关键字确保数据同步

案例三：按顺序加锁避免死锁

六、总结

继承`Thread`类

实现`Runnable`接口

使用`ExecutorService`

调用`start`方法

`run`方法的执行

案例二：使用`synchronized`关键字确保数据同步