Java多线程的实现方式

Java中实现多线程有多种方式，主要可以归纳为以下几种：

继承Thread类

创建一个新的类继承自Thread类，并重写run()方法。在run()方法中编写线程要执行的代码。通过调用Thread类的start()方法来启动线程。

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

实现Runnable接口

创建一个类实现Runnable接口，并重写run()方法。然后创建Thread对象时，将Runnable接口的实现作为构造参数传入。

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

实现Callable接口

Callable接口类似于Runnable，但是它可以返回一个结果，并且可以抛出异常。Callable接口的实现类需要重写call()方法，而不是run()方法。

     import java.util.concurrent.Callable;

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

使用ExecutorService和线程池

ExecutorService接口提供了一种更高级的线程管理和控制机制，可以使用线程池来管理一组线程，而不是为每个任务创建和销毁线程。

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

     ExecutorService executor = Executors.newFixedThreadPool(5);
     executor.submit(new MyRunnable());
     executor.shutdown();

使用CompletableFuture

CompletableFuture是Java 8引入的一个新特性，它提供了一种异步编程模型，可以用于处理异步计算和回调。

     CompletableFuture.supplyAsync(() -> {
         return "Future result";
     }).thenAccept(System.out::println);

使用ForkJoinPool和RecursiveTask或RecursiveAction

ForkJoinPool是Java中用于处理分治算法的专用线程池，它支持任务的递归分解和合并。

     import java.util.concurrent.ForkJoinPool;
     import java.util.concurrent.RecursiveTask;

     class MyRecursiveTask extends RecursiveTask<Integer> {
         // 实现递归任务...
     }

     ForkJoinPool pool = new ForkJoinPool();
     pool.invoke(new MyRecursiveTask());

每种方式都有其适用场景和优缺点，选择哪种方式取决于具体的需求和对线程控制的精细程度。例如，使用Thread类或Runnable接口适用于简单的线程任务，而使用ExecutorService和线程池则更适合于需要管理大量线程和资源回收的场景。