在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多線程的幾種常見方式，可以根據具體需求選擇合適的方法。