在Java中创建子线程是实现多线程编程的基础,能够让程序同时执行多个任务，提高CPU利用率和程序响应速度，Java提供了多种创建子线程的方式，每种方式都有其特点和适用场景，开发者可以根据需求选择合适的方法。
继承Thread类创建线程
继承Thread类是最基础的创建线程方式,通过自定义一个类继承Thread类，并重写其run()方法，将需要在线程中执行的代码放入run()方法中，然后创建该自定义类的实例，调用start()方法启动线程，需要注意的是，调用start()方法会启动线程并使其处于可运行状态，由JVM调度执行run()方法中的代码，如果直接调用run()方法，则不会创建新的线程，而是在当前线程中执行run()方法内的代码。
示例代码如下：
class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线程：" + i);
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start();
for (int i = 0; i < 5; i++) {
System.out.println("主线程：" + i);
}
}
}
这种方式的优点是简单直观,易于理解，缺点是由于Java是单继承的，如果自定义类已经继承了其他类，就无法再继承Thread类，因此灵活性较差。
实现Runnable接口创建线程
实现Runnable接口是另一种常见的创建线程的方式,通过自定义一个类实现Runnable接口，并实现其run()方法，然后将该实例作为参数传递给Thread类的构造方法，创建Thread对象后调用start()方法启动线程，这种方式的优势在于避免了单继承的限制，且多个线程可以共享同一个Runnable实例，适合多个线程处理同一份数据的场景。
示例代码如下：
class MyRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("子线程：" + i);
}
}
}
public class RunnableDemo {
public static void main(String[] args) {
MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();
for (int i = 0; i < 5; i++) {
System.out.println("主线程：" + i);
}
}
}
与继承Thread类相比,实现Runnable接口更加灵活，是Java中推荐使用的创建线程的方式之一。
使用Callable和Future创建线程
Callable接口类似于Runnable接口,但两者有显著区别：Callable的call()方法可以有返回值，并且可以抛出异常，通过实现Callable接口，可以在线程执行完成后获取返回结果，Future接口则代表异步计算的结果，通过它可以检查计算是否完成、获取计算结果或取消计算。
使用Callable和Future创建线程需要借助线程池（ExecutorService），首先创建一个实现了Callable接口的类，然后通过线程池的submit()方法提交任务，该方法会返回一个Future对象，通过该对象可以获取线程执行的结果。
示例代码如下：
import java.util.concurrent.*;
class MyCallable implements Callable<Integer> {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 1; i <= 5; i++) {
sum += i;
}
return sum;
}
}
public class CallableDemo {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(1);
Future<Integer> future = executor.submit(new MyCallable());
try {
Integer result = future.get();
System.out.println("线程执行结果：" + result);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
executor.shutdown();
}
}
这种方式的优点是可以获取线程的执行结果,适合需要返回值的场景，缺点是代码相对复杂，需要处理线程池的关闭等操作。
使用线程池创建线程
线程池是一种管理线程的有效方式,它可以复用已创建的线程，减少频繁创建和销毁线程带来的性能开销，Java提供了Executor框架，通过Executors工厂类可以创建不同类型的线程池，如固定大小的线程池（newFixedThreadPool）、单线程线程池（newSingleThreadExecutor）和缓存线程池（newCachedThreadPool）等。
使用线程池创建线程的步骤如下：1. 通过Executors工厂类创建线程池；2. 定义Runnable或Callable任务；3. 调用线程池的execute()方法（用于Runnable任务）或submit()方法（用于Callable任务）提交任务；4. 关闭线程池（调用shutdown()方法）。
示例代码如下：
import java.util.concurrent.*;
public class ThreadPoolDemo {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(2);
for (int i = 0; i < 3; i++) {
executor.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程名：" + Thread.currentThread().getName() + " 执行任务");
}
});
}
executor.shutdown();
}
}
线程池特别适合处理大量短期异步任务的场景,可以有效控制系统中线程的数量，避免因线程过多导致系统资源耗尽。
创建线程的注意事项
在创建和使用子线程时,需要注意以下几点：1. 线程同步问题：当多个线程共享数据时，需要使用同步机制（如synchronized关键字、Lock接口）来保证数据的一致性；2. 线程安全问题：避免在多线程环境下使用可变共享变量，或者对共享变量进行适当的同步处理；3. 线程的生命周期管理：合理控制线程的创建、运行和销毁，避免线程泄漏；4. 异常处理：子线程中的异常不会抛出到主线程，需要在run()方法内部捕获和处理异常，或者通过UncaughtExceptionHandler接口处理未捕获的异常。
Java提供了多种创建子线程的方式,开发者应根据具体需求选择合适的方法，在实际开发中，合理使用多线程可以提高程序的执行效率，但也需要注意线程安全和资源管理，避免因多线程引发的问题。
