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接口，并重写其call()方法。然后使用ExecutorService框架提交Callable任务，并得到Future对象。可以通过Future对象的get()方法获取任务执行结果。

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();
        System.out.println("Result: " + result);
        executorService.shutdown();
    }
}

4. 使用Java 8的CompletableFuture：创建一个函数式接口，例如Function<T, R>，然后使用CompletableFuture类的supplyAsync()方法异步执行该接口的实现。可以通过thenApply()、thenAccept()等方法处理异步计算结果。

import java.util.concurrent.CompletableFuture;

@FunctionalInterface
interface MyFunction<T, R> {
    R apply(T t);
}

public class Main {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            // 代码逻辑
            return 42;
        });

        future.thenAccept(result -> {
            System.out.println("Result: " + result);
        });
    }
}

这些方法都可以用于实现多线程，具体选择哪种方法取决于你的需求和编程风格。