在Java中，可以使用多種方法來實現多線程并發編程。以下是一些建議的方法：

1. 繼承Thread類： 創建一個類，繼承自java.lang.Thread類，并重寫其run()方法。然后創建該類的對象，并調用start()方法來啟動線程。

class MyThread extends Thread {
    public void run() {
        // 線程執行的代碼
    }
}

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

2. 實現Runnable接口： 創建一個類，實現java.lang.Runnable接口，并重寫其run()方法。然后創建該接口的實現類的對象，將該對象作為參數傳遞給Thread類的構造方法，并調用start()方法來啟動線程。

class MyRunnable implements Runnable {
    public void run() {
        // 線程執行的代碼
    }
}

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

3. 使用ExecutorService： Java提供了ExecutorService接口和Executors工具類來更方便地管理線程池。使用ExecutorService，可以創建固定數量的線程來并發執行任務。

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

class MyRunnable implements Runnable {
    public void run() {
        // 線程執行的代碼
    }
}

public class Main {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        executorService.submit(new MyRunnable());
        executorService.submit(new MyRunnable());
        executorService.shutdown();
    }
}

4. 使用Callable接口和Future： Java提供了Callable接口，它允許線程返回一個結果。使用Future類可以獲取異步計算的結果。

import java.util.concurrent.*;

class MyCallable implements Callable<Integer> {
    public Integer call() throws Exception {
        // 線程執行的代碼，返回一個整數結果
        return 0;
    }
}

public class Main {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Future<Integer> future = executorService.submit(new MyCallable());
        try {
            Integer result = future.get(); // 獲取線程執行的結果
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executorService.shutdown();
        }
    }
}

這些方法可以幫助你在Java中實現多線程并發編程。在實際項目中，你可能需要根據具體需求選擇合適的方法。同時，為了避免多線程帶來的問題，如資源競爭和數據不一致等，你需要使用同步機制（如synchronized關鍵字、Lock接口、Semaphore類等）來確保線程安全。