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

這些方法都可以用于實現多線程，具體選擇哪種方法取決于你的需求和編程風格。