java 的线程怎么创建

Java中，线程的创建方式多种多样，每种方式都有其独特的优势和适用场景,以下是几种常见的线程创建方法及其详细解释：

继承Thread类

实现方式

通过继承Thread类并重写run()方法来定义线程的执行逻辑，然后创建该类的实例并调用start()方法启动线程。

示例代码

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程正在运行：" + Thread.currentThread().getName());
    }
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

优点

• 简单直观,适合初学者理解线程的基本概念。
• 可以直接访问和修改线程的属性（如优先级、名称等）。

缺点

• 由于Java的单继承机制，继承了Thread类的子类无法再继承其他类,限制了类的扩展性。
• 任务逻辑与线程对象耦合度高,不利于代码的复用和维护。

实现Runnable接口

实现方式

创建一个实现了Runnable接口的类，并将run()方法中的逻辑作为线程的执行体，然后将该Runnable对象传递给Thread类的构造函数,创建并启动线程。

示例代码

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("线程正在运行：" + Thread.currentThread().getName());
    }
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
    }
}

优点

• 解耦了任务逻辑和线程对象,提高了代码的灵活性和可维护性。
• 避免了单继承的限制,允许类同时实现多个接口。

缺点

• 无法直接获取线程的执行结果，需要通过其他方式（如共享变量）进行通信。
• 需要额外创建Thread对象来启动线程。

使用Callable和FutureTask

实现方式

Callable接口是Java 5引入的，与Runnable类似，但Callable的call()方法可以返回结果，并且可以抛出异常，通常将Callable对象包装在FutureTask中，然后通过Thread来执行。

示例代码

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "线程返回结果：" + Thread.currentThread().getName();
    }
    public static void main(String[] args) {
        MyCallable callable = new MyCallable();
        FutureTask<String> futureTask = new FutureTask<>(callable);
        Thread thread = new Thread(futureTask);
        thread.start();
        try {
            String result = futureTask.get(); // 阻塞直到任务完成
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

优点

• 支持返回值和异常处理,适用于需要获取线程执行结果的场景。
• 提供了更强大的功能，如超时控制、任务取消等。

缺点

• 代码复杂度较高，需要结合FutureTask使用。
• get()方法会阻塞当前线程,直到任务完成。

使用线程池（Executor框架）

实现方式

Java提供了ExecutorService接口和多种线程池实现（如FixedThreadPool、CachedThreadPool等），通过线程池可以高效地管理和复用线程,避免频繁创建和销毁线程的开销。

示例代码

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建固定大小的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        for (int i = 0; i < 5; i++) {
            final int taskId = i;
            executorService.execute(() -> {
                System.out.println("任务" + taskId + "正在执行，线程：" + Thread.currentThread().getName());
            });
        }
        // 关闭线程池
        executorService.shutdown();
    }
}

优点

• 高效管理线程生命周期,减少资源消耗。
• 提供任务队列、拒绝策略、监控等功能,适用于高并发场景。

缺点

• 需要合理配置线程池参数（如核心线程数、最大线程数等）,否则可能导致资源浪费或任务积压。
• 线程池的关闭需要显式调用shutdown()或shutdownNow()方法。

使用Lambda表达式（Java 8及以上）

实现方式

在Java 8及以上版本中，可以使用Lambda表达式简化Runnable的实现,使代码更加简洁。

示例代码

public class LambdaThreadExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("线程正在运行：" + Thread.currentThread().getName());
        });
        thread.start();
    }
}

优点

• 代码简洁,减少了冗余代码。
• 适用于简单的任务逻辑,提高开发效率。

缺点

• 仅适用于Runnable接口的简单实现,无法获取线程执行结果。
• 对于复杂任务，仍需使用其他方式（如Callable或线程池）。

归纳对比

相关问答FAQs

问题1：为什么直接调用Thread.run()方法不会创建新线程？
答：直接调用Thread.run()方法会在当前线程中执行run()方法中的代码，而不是创建新线程，只有调用Thread.start()方法才会启动一个新线程，并在新线程中执行run()方法，这是因为start()方法会调用JVM的底层方法来创建新线程，而run()方法只是一个普通的实例方法。

问题2：如何获取线程的执行结果？
答：如果使用Runnable接口创建线程，无法直接获取执行结果，此时可以通过共享变量或其他通信机制来传递结果，如果需要直接获取线程的执行结果，可以使用Callable接口和FutureTask。Callable的call()方法可以返回结果，并通过FutureTask.get()方法获取该结果。

FutureTask<Integer> futureTask = new FutureTask<>(() -> {
    // 执行任务并返回结果
    return 42;
});
new Thread(futureTask).start();
int result = futureTask.get(); // 获取线程执行结果