Java中创建线程的5种主流方法与对比

继承 Thread 类创建线程

Thread 类是 Java 中表示线程的类，直接继承它并重写 run 方法是早期常用的做法。由于 Java 单继承的限制，这种方式一旦使用便无法再继承其他业务类。

第1步：普通类继承 Thread

创建一个独立的类继承 Thread，在重写的 run 方法中编写核心逻辑。在主线程中实例化该类并调用 start() 启动。

// 定义线程类
class MyThread extends Thread {
    @Override
    public void run() {
        // 具体的业务逻辑...
    }
}

// 调用示例
public static void main(String[] args) {
    Thread thread = new MyThread();
    thread.start(); // 启动线程
}

第2步：匿名内部类实现

若不想单独建一个类，可以直接在创建 Thread 对象时通过匿名内部类覆盖 run 方法。语法更紧凑，但可读性略弱。

Thread t1 = new Thread() {
    @Override
    public void run() {
        // 具体的业务逻辑...
    }
};
t1.start(); // 启动线程

注意：以上两种继承方式的共同局限是无法让当前类继承其他父类，且不能直接获取线程执行后的返回值。

实现 Runnable 接口创建线程

实现 Runnable 接口将“线程任务”与“线程载体”分离，避免了单继承的缺陷，是更推荐的基础方式。以下是三种常用形态：

第3步：普通类实现 Runnable

创建一个类实现 Runnable 接口，将其实例作为参数传给 new Thread() 构造函数。

// 定义任务类
class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 具体的业务逻辑...
    }
}

// 调用示例
public static void main(String[] args) {
    Runnable myRunnable = new MyRunnable();
    Thread thread = new Thread(myRunnable);
    thread.start();
}

第4步：匿名内部类实现 Runnable

直接在创建线程时传入匿名实现的 Runnable 对象，适合短小且不复用的任务。

Thread t2 = new Thread(new Runnable() {
    @Override
    public void run() {
        // 具体的业务逻辑...
    }
});
t2.start(); // 启动线程

第5步：使用 Lambda 表达式 (JDK 8+)

JDK 8 引入了 Lambda 特性，使 Runnable 的实现变得极其简洁。对于不需要返回结果的轻量级任务，这是目前最优雅的选择。

Thread t3 = new Thread(() -> {
    // 具体的业务逻辑...
});
t3.start(); // 启动线程

实现 Callable 接口获取执行结果

如果任务运行结束后需要返回特定类型的结果（如计算总和），可以使用 Callable。它与 Runnable 类似，但支持泛型返回值并能抛出检查异常。通常配合 FutureTask 进行结果获取。

第6步：普通类实现 Callable

实现 Callable<Integer>（以整数为例），重写 call 方法。通过 FutureTask 包装后传递给 Thread，并通过 get() 阻塞获取返回值。

// 定义带返回值的任务
class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        // 模拟耗时计算...
        return 0;
    }
}

// 调用示例
public static void main(String[] args) throws ExecutionException, InterruptedException {
    MyCallable callable = new MyCallable();
    FutureTask<Integer> futureTask = new FutureTask<>(callable);
    Thread thread = new Thread(futureTask);
    thread.start();
    
    // 阻塞直到结果可用
    int result = futureTask.get();
    System.out.println("结果为: " + result);
}

第7步：匿名内部类实现 Callable

同样支持匿名内部类写法，用于一次性任务：

FutureTask<Integer> futureTask = new FutureTask<>(new Callable<Integer>() {
    @Override
    public Integer call() throws Exception {
        // 模拟耗时计算...
        return 0;
    }
});
Thread thread = new Thread(futureTask);
thread.start();
int result = futureTask.get(); // 获取返回值

总结

在 Java 中创建线程，优先推荐使用 Runnable 接口或 JDK 8 的 Lambda 表达式，因为它们灵活且不破坏类的继承结构。只有在必须获取线程执行结果（如异步计算）时，才建议使用 Callable 配合 FutureTask。
以上就是Java都有哪些创建线程的详细内容，更多关于Java创建线程的资料请关注本站其它相关文章！