面试题：Java 中如何创建多线程？

在 Java 中，创建多线程主要有以下几种方式：

1. 继承 `Thread` 类

通过继承 Thread 类并重写 run() 方法来创建线程。

步骤：

创建一个类并继承 Thread。
重写 run() 方法，定义线程执行的任务。
创建该类的实例并调用 start() 方法启动线程。

示例：

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread is running: " + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();

        thread1.start(); // 启动线程 1
        thread2.start(); // 启动线程 2
    }
}

注意：

直接调用 run() 方法不会启动新线程，而是在当前线程中执行。
一个线程实例只能调用一次 start() 方法。

2. 实现 `Runnable` 接口

通过实现 Runnable 接口并重写 run() 方法来创建线程。

步骤：

创建一个类并实现 Runnable 接口。
重写 run() 方法，定义线程执行的任务。
创建 Thread 实例，传入 Runnable 对象。
调用 start() 方法启动线程。

示例：

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Thread is running: " + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();

        Thread thread1 = new Thread(myRunnable);
        Thread thread2 = new Thread(myRunnable);

        thread1.start(); // 启动线程 1
        thread2.start(); // 启动线程 2
    }
}

优点：

避免单继承的限制（Java 不支持多继承）。
更适合多个线程共享资源的场景。

3. 实现 `Callable` 接口

通过实现 Callable 接口并重写 call() 方法来创建线程。Callable 与 Runnable 的主要区别是 Callable 可以返回结果并抛出异常。

步骤：

创建一个类并实现 Callable 接口。
重写 call() 方法，定义线程执行的任务。
创建 FutureTask 实例，传入 Callable 对象。
创建 Thread 实例，传入 FutureTask 对象。
调用 start() 方法启动线程。
通过 FutureTask.get() 方法获取线程执行的结果。

示例：

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

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "Thread is running: " + Thread.currentThread().getName();
    }

    public static void main(String[] args) throws Exception {
        MyCallable myCallable = new MyCallable();

        FutureTask<String> futureTask = new FutureTask<>(myCallable);
        Thread thread = new Thread(futureTask);

        thread.start(); // 启动线程
        System.out.println(futureTask.get()); // 获取线程执行结果
    }
}

优点：

支持返回值。
支持异常处理。

4. 使用线程池

通过线程池（ExecutorService）来管理和执行多线程任务。线程池可以复用线程，减少线程创建和销毁的开销。

步骤：

创建线程池（如 Executors.newFixedThreadPool()）。
提交任务（如 execute() 或 submit()）。
关闭线程池（如 shutdown()）。

示例：

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

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);

        Runnable task1 = () -> System.out.println("Task 1 is running: " + Thread.currentThread().getName());
        Runnable task2 = () -> System.out.println("Task 2 is running: " + Thread.currentThread().getName());

        executor.execute(task1); // 提交任务 1
        executor.execute(task2); // 提交任务 2

        executor.shutdown(); // 关闭线程池
    }
}

优点：

提高线程的复用性。
减少线程创建和销毁的开销。
提供更好的线程管理。

5. 使用 `CompletableFuture`（Java 8+）

CompletableFuture 是 Java 8 引入的类，用于实现异步编程和任务编排。

示例：

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println("Task is running asynchronously: " + Thread.currentThread().getName());
        });

        future.join(); // 等待任务完成
    }
}

优点：