Java常见的创建线程的方法

方法一：继承 Thread 类

通过继承 Thread 类来创建线程，在子类中重写 run() 方法来定义线程执行的任务。

typescript 复制代码

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

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

方法二：实现 Runnable 接口

通过实现 Runnable 接口来创建线程，可以避免单继承的限制，同时将线程的任务与线程本身分离。

typescript 复制代码

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

    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable); // 将实现了 Runnable 接口的对象传入 Thread 的构造函数
        thread.start(); // 启动线程
    }
}

这两种方法都能够成功创建并启动线程，但通常推荐使用实现 Runnable 接口的方式，因为它更灵活，能够更好地支持面向对象设计原则。

方法三：使用匿名类创建线程

typescript 复制代码

java
public class ThreadExample {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Thread is running");
            }
        });
        thread.start();
    }
}

方法四：使用 Lambda 表达式创建线程

arduino 复制代码

java
public class ThreadExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("Thread is running");
        });
        thread.start();
    }
}

在上述示例中，我们使用匿名类和 Lambda 表达式分别创建了一个线程，这两种方法都能简洁地定义线程执行的任务。使用 Lambda 表达式可以更加简洁地表示线程的运行逻辑，特别适合于只包含单个方法的接口（如 Runnable 接口）。

方法五：使用 Callable 和 Future 接口可以创建并管理线程

使用 Callable 和 Future 接口可以创建并管理线程，并且可以获取线程执行的结果。下面是一个示例说明如何使用 Callable 和 Future 接口来创建和管理线程：

java 复制代码

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

public class ThreadExample {
    public static void main(String[] args) {
        Callable<Integer> task = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println("Thread is running");
                return 42; // 返回一个结果
            }
        };

        FutureTask<Integer> futureTask = new FutureTask<>(task);
        Thread thread = new Thread(futureTask);
        thread.start();

        try {
            int result = futureTask.get(); // 获取线程执行结果
            System.out.println("Thread result: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

在上述示例中，我们首先创建了一个 Callable 对象来定义线程执行的任务，然后将其封装在 FutureTask 中。接着，我们创建一个线程对象，将 FutureTask 对象传递给线程，并启动线程。最后，通过调用 futureTask.get() 方法可以获取线程执行的结果。

使用 Callable 和 Future 接口可以更灵活地控制线程的执行和获取线程的返回结果，特别适合需要在多线程任务中获取返回值的情况。