简单易懂——Java 中创建线程的几种方式

Java 中创建线程的几种方式

在 Java 中，线程是一种轻量级的执行单元，可以同时执行多个任务。本文详细介绍了创建线程的几种常见方式，并提供了完整的解释和示例代码，方便大家根据实际需求选择合适的方法。

---

1. 继承 Thread 类

原理说明：
通过继承 Thread 类，重写其 run() 方法来定义线程执行的任务，然后调用 start() 方法启动线程。
注意：由于 Java 是单继承，如果一个类已经继承了其他类，就不能再继承 Thread 类。

示例代码：

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Hello from MyThread");
    }
    
    public static void main(String[] args) {
        MyThread t = new MyThread();
        t.start();  // 启动线程，调用 run() 方法
    }
}

---

2. 实现 Runnable 接口

原理说明：
实现 Runnable 接口，并在 run() 方法中定义任务逻辑。然后通过将 Runnable 实现类的实例传递给 Thread 构造器来创建线程。
优点：这种方式可以避免 Java 的单继承限制，同时允许多个线程共享同一份资源。

示例代码：

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Hello from MyRunnable");
    }
    
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start();  // 启动线程，调用 run() 方法
    }
}

---

3. 使用 Callable 接口和 FutureTask

原理说明：
当需要线程在结束后返回一个计算结果时，可以使用 Callable 接口。与 Runnable 不同，Callable 的 call() 方法可以返回值并抛出异常。通常，我们将 Callable 对象包装在 FutureTask 中，再将其传递给 Thread 对象进行执行。

示例代码：

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        return 42;
    }
    
    public static void main(String[] args) throws Exception {
        FutureTask<Integer> task = new FutureTask<>(new MyCallable());
        Thread t = new Thread(task);
        t.start();
        
        // 获取线程执行后的返回结果
        Integer result = task.get();
        System.out.println("Result: " + result);
    }
}

---

4. 使用线程池（Executor 框架）

原理说明：
线程池能够管理和复用线程，适用于处理大量短生命周期的任务。Java 的 Executor 框架提供了多种线程池实现，例如 Executors.newFixedThreadPool()、Executors.newCachedThreadPool() 等。
优点：通过任务提交和线程调度的分离，可以提高性能并降低资源消耗，同时便于线程管理。

示例代码：

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

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个固定大小为2的线程池
        ExecutorService executor = Executors.newFixedThreadPool(2);
        
        // 提交一个 Runnable 任务
        executor.execute(new Runnable(){
            @Override
            public void run() {
                System.out.println("Hello from thread pool");
            }
        });
        
        // 关闭线程池
        executor.shutdown();
    }
}

---

小结

• 继承 Thread 类：实现简单，但受限于 Java 的单继承特性。
• 实现 Runnable 接口：更灵活，适用于任务共享和资源复用。
• 使用 Callable 和 FutureTask：适合需要返回结果和异常处理的任务。
• 线程池（Executor 框架）：适合管理大量任务和复用线程资源，从而提高系统性能。

选择哪种方式取决于具体应用场景和需求。