JAVA多线程实现的三种方式

JAVA多线程实现的三种方式在Java中实现多线程有三种主要方式：

1. 继承Thread类：
   这种方式通过继承java.lang.Thread类并重写run方法来实现多线程。继承Thread类后，创建实例并调用start方法启动新线程。

   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();
       }
   }
   

2. 实现Runnable接口：
   这种方式通过实现java.lang.Runnable接口并重写run方法。然后，将实现了Runnable接口的实例传递给Thread对象，并调用start方法启动新线程。

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

       public static void main(String[] args) {
           Thread thread = new Thread(new MyRunnable());
           thread.start();
       }
   }
   

3. 使用Callable和Future接口：
   这种方式通过实现java.util.concurrent.Callable接口，并重写call方法。Callable接口与Runnable不同，它可以返回结果或抛出异常。然后使用java.util.concurrent.FutureTask类来处理返回结果，并将其传递给Thread对象启动新线程。

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

   public class MyCallable implements Callable<String> {
       @Override
       public String call() throws Exception {
           return "Callable result";
       }

       public static void main(String[] args) {
           MyCallable callable = new MyCallable();
           FutureTask<String> futureTask = new FutureTask<>(callable);
           Thread thread = new Thread(futureTask);
           thread.start();

           try {
               System.out.println("Result from callable: " + futureTask.get());
           } catch (InterruptedException | ExecutionException e) {
               e.printStackTrace();
           }
       }
   }
   

这三种方式各有优缺点，具体选择哪种方式取决于实际需求：

- 继承Thread类：比较简单，适合需要直接操作线程的情况，但由于Java不支持多重继承，这种方式会有一定的局限性。
- 实现Runnable接口：灵活性更高，可以避免多重继承的问题，更适合多个线程共享同一个资源的情况。
- 使用Callable和Future接口：适合需要线程返回结果或抛出异常的情况，同时提供了更强的并发处理能力。