Java创建线程的方式

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

1. **继承Thread类**：创建一个新的类继承`java.lang.Thread`类，重写其`run()`方法，在`run()`方法中定义需要并行执行的代码。然后创建该类的实例，并调用其`start()`方法来启动新线程。

   ```java
   class MyThread extends Thread {
       public void run() {
           System.out.println("通过继承Thread类创建线程");
       }
   }

   public class Main {
       public static void main(String[] args) {
           MyThread t = new MyThread();
           t.start();
       }
   }
   ```

2. **实现Runnable接口**：创建一个类实现`java.lang.Runnable`接口，实现`run()`方法。然后将该类的实例作为参数传递给`Thread`类的构造器，创建`Thread`对象，最后调用`Thread`对象的`start()`方法来启动线程。

   ```java
   class MyRunnable implements Runnable {
       public void run() {
           System.out.println("通过实现Runnable接口创建线程");
       }
   }

   public class Main {
       public static void main(String[] args) {
           Thread t = new Thread(new MyRunnable());
           t.start();
       }
   }
   ```

3. **实现Callable接口和FutureTask**：与`Runnable`接口不同，`java.util.concurrent.Callable`接口提供了一个带返回值的`call()`方法。要使用`Callable`，需要将它包装进一个`FutureTask`，因为`Thread`类只能接受`Runnable`对象。`FutureTask`同时提供了检查计算结果是否完成的方法。

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

   class MyCallable implements Callable<String> {
       public String call() throws Exception {
           return "通过实现Callable接口创建线程";
       }
   }

   public class Main {
       public static void main(String[] args) {
           MyCallable callable = new MyCallable();
           FutureTask<String> futureTask = new FutureTask<>(callable);
           Thread t = new Thread(futureTask);
           t.start();
           try {
               System.out.println(futureTask.get()); // 获取并打印返回结果
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
   }
   ```

4. **使用线程池（Executor框架）**：从Java 5开始引入的`java.util.concurrent.ExecutorService`和相关类提供了线程池的实现，这是一种更高效的线程管理方式，可以重复利用已创建的线程，减少线程创建和销毁的开销。

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

   public class Main {
       public static void main(String[] args) {
           ExecutorService executorService = Executors.newFixedThreadPool(2); // 创建固定大小的线程池
           executorService.submit(() -> System.out.println("通过线程池创建线程"));
           executorService.shutdown(); // 使用完毕后关闭线程池
       }
   }
   ```