Java中创建线程的几种方式及其区别

Java中创建线程主要有以下几种方式，每种方式有其特定的适用场景和优缺点。

1. 继承Thread类

这是最基本的方式，通过继承Thread类并重写run()方法来定义线程执行的任务。

class MyThread extends Thread {
    @Override
    public void run() {
        // 线程执行的代码
        System.out.println("Thread is running: " + Thread.currentThread().getName());
    }
}

// 使用方式
MyThread thread = new MyThread();
thread.start();  // 启动线程

特点：

• 简单直接，适合简单的线程任务
• 由于Java单继承限制，无法再继承其他类
• 每个线程对象都是独立的，不能共享资源

2. 实现Runnable接口

当一个类已经继承了其他类时，可以通过实现Runnable接口来创建线程。

class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程执行的代码
        System.out.println("Thread is running: " + Thread.currentThread().getName());
    }
}

// 使用方式
Thread thread = new Thread(new MyRunnable());
thread.start();  // 启动线程

// 或者使用Lambda表达式（Java 8+）
Thread thread = new Thread(() -> {
    System.out.println("Thread is running: " + Thread.currentThread().getName());
});
thread.start();

特点：

• 避免了单继承的限制，更加灵活
• 多个线程可以共享同一个Runnable实例，适合资源共享场景
• 无法直接获取线程执行结果
• run()方法不能抛出检查异常

3. 实现Callable接口

Callable接口与Runnable类似，但可以返回结果并抛出异常。需要通过FutureTask包装才能被Thread执行。

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

class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        // 线程执行的代码，可以返回结果
        System.out.println("Thread is running: " + Thread.currentThread().getName());
        return 123;
    }
}

// 使用方式
FutureTask<Integer> futureTask = new FutureTask<>(new MyCallable());
Thread thread = new Thread(futureTask);
thread.start();  // 启动线程

// 获取线程执行结果
try {
    Integer result = futureTask.get();  // 阻塞，直到线程执行完成
    System.out.println("Result: " + result);
} catch (Exception e) {
    e.printStackTrace();
}

特点：

• 可以返回执行结果
• 可以抛出检查异常
• 需要通过FutureTask包装，使用相对复杂
• 可以通过Future获取任务状态和结果

4. 使用线程池（ExecutorService）

Java提供了ExecutorService框架，可以更高效地管理线程资源。

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

class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程执行的代码
        System.out.println("Thread is running: " + Thread.currentThread().getName());
    }
}

// 使用方式
ExecutorService executorService = Executors.newFixedThreadPool(5);  // 创建固定大小的线程池
executorService.execute(new MyRunnable());  // 执行Runnable任务

// 使用Lambda表达式
executorService.execute(() -> {
    System.out.println("Thread is running: " + Thread.currentThread().getName());
});

// 提交Callable任务
Future<Integer> future = executorService.submit(() -> {
    System.out.println("Thread is running: " + Thread.currentThread().getName());
    return 123;
});

// 获取结果
try {
    Integer result = future.get();  // 阻塞，直到任务完成
    System.out.println("Result: " + result);
} catch (Exception e) {
    e.printStackTrace();
}

// 关闭线程池
executorService.shutdown();

特点：

• 线程可重用，减少创建和销毁的开销
• 提供了更好的线程管理和控制
• 可以控制并发线程数量
• 支持定时执行、周期执行等高级功能
• 可以执行Runnable和Callable任务

5. 各种方式的区别

6. 最佳实践

在实际开发中，推荐使用以下方式创建线程：

1. 优先使用线程池：线程池可以重用线程，减少创建和销毁线程的开销，提高系统性能。同时，线程池提供了更好的线程管理和控制。

2. 使用Runnable或Callable：相比继承Thread类，实现接口的方式更加灵活，可以避免Java单继承的限制。

3. 需要返回值时使用Callable：如果需要获取线程执行的结果，应该使用Callable接口，通过Future获取返回值。

4. 避免显式创建Thread：除非有特殊需求，否则应该避免直接创建Thread对象，而是通过线程池来管理线程。

5. 注意资源释放：使用线程池时，记得在不再需要时调用shutdown()方法关闭线程池，释放资源。

参考资料

• Java Thread类官方文档
• Java Runnable接口官方文档
• Java Callable接口官方文档
• Java ExecutorService接口官方文档
• Java并发编程实战