创建线程的几种方式

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

1. 继承Thread类：创建一个继承自Thread类的子类，并重写run()方法来定义线程的执行逻辑。

public class MyThread extends Thread {
    public void run() {
        // 线程执行的逻辑代码
    }
}
// 创建并启动线程
MyThread myThread = new MyThread();
myThread.start();

2. 实现Runnable接口：创建一个实现了Runnable接口的类，并实现其run()方法来定义线程的执行逻辑。然后将该Runnable对象传递给Thread类的构造函数创建一个线程对象。

public class MyRunnable implements Runnable {
    public void run() {
        // 线程执行的逻辑代码
    }
}
// 创建并启动线程
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();

3. 使用匿名内部类：可以在创建Thread或Runnable对象的同时定义其run()方法的实现逻辑。

// 使用匿名内部类创建并启动线程
Thread thread = new Thread(new Runnable() {
    public void run() {
        // 线程执行的逻辑代码
    }
});
thread.start();

4. 使用Lambda表达式：可以使用Lambda表达式替代匿名内部类来创建线程。

// 使用Lambda表达式创建并启动线程
Thread thread = new Thread(() -> {
    // 线程执行的逻辑代码
});
thread.start();

5. 通过 Callable 和 Future 接口创建线程
   通过Callable和Future接口可以创建带有返回值的线程。Callable接口是一个泛型接口，它定义了一个call()方法，该方法可以在新线程中执行，并返回一个结果。Future接口用于表示异步计算的结果，它提供了一些方法来检查任务的状态和获取任务的结果。
   以下是使用Callable和Future接口创建线程的示例代码：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class MyCallable implements Callable<Integer> {
    public Integer call() throws Exception {
        // 在这里编写线程的逻辑代码
        int result = 0;
        for (int i = 1; i <= 10; i++) {
            result += i;
        }
        return result;
    }
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Callable<Integer> callable = new MyCallable();
        Future<Integer> future = executor.submit(callable);
        try {
            // 获取线程的执行结果
            int result = future.get();
            System.out.println("线程的执行结果：" + result);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
}

在上述代码中，创建了一个实现了Callable接口的MyCallable类，并重写了call()方法来定义线程的逻辑代码。在main()方法中，通过ExecutorService的submit()方法将MyCallable对象提交给线程池执行，并返回一个Future对象。然后通过调用Future对象的get()方法来获取线程的执行结果。

需要注意的是，Future对象的get()方法会阻塞当前线程，直到获取到线程的执行结果或发生异常。如果希望在线程执行超时之后取消线程的执行，可以使用Future对象的cancel()方法。

最后，在不再需要线程池时，需要调用ExecutorService对象的shutdown()方法来关闭线程池。
无论使用哪种方式创建线程，最终都需要调用线程对象的start()方法来启动线程的执行。当线程启动后，会自动调用run()方法中定义的逻辑代码。

需要注意的是，使用继承Thread类的方式只能继承一个类，而使用实现Runnable接口的方式可以实现多重接口。另外，使用Runnable接口的方式更符合面向对象的设计原则，推荐使用该方式来创建线程。