java实现多线程的几种方式

在Java中，实现多线程主要有以下几种方式：

1. 继承Thread类：创建一个新的类，继承自Thread类，并重写其run()方法。然后创建该类的实例，并调用start()方法来启动新线程。

class MyThread extends Thread {
    public void run() {
        // 代码逻辑
    }
}

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

2. 实现Runnable接口：创建一个新的类，实现Runnable接口，并重写其run()方法。然后创建该类的实例，并将其作为参数传递给Thread类的构造函数。最后调用Thread实例的start()方法来启动新线程。

class MyRunnable implements Runnable {
    public void run() {
        // 代码逻辑
    }
}

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

3. 使用Callable和Future：创建一个实现Callable接口的类，该接口包含一个返回值和一个异常。然后使用FutureTask类来包装Callable对象，该类实现了RunnableFuture接口。最后，将FutureTask对象传递给Executor框架（如ExecutorService）来执行。

class MyCallable implements Callable<Integer> {
    public Integer call() throws Exception {
        // 代码逻辑
        return 42;
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Future<Integer> future = executorService.submit(new MyCallable());
        Integer result = future.get(); // 获取任务执行结果
        executorService.shutdown();
    }
}

4. 使用Java 8的CompletableFuture：CompletableFuture是Java 8引入的一个强大的异步编程工具，它提供了丰富的方法来处理异步计算的结果。

import java.util.concurrent.CompletableFuture;

class MyCompletableFuture {
    public static CompletableFuture<Integer> compute() {
        return CompletableFuture.supplyAsync(() -> {
            // 代码逻辑
            return 42;
        });
    }
}

public class Main {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = MyCompletableFuture.compute();
        future.thenAccept(result -> {
            // 处理任务执行结果
        });
    }
}

这些是实现Java多线程的几种常见方式，可以根据具体需求选择合适的方法。