在Java中，為了確保多線程在執行時能夠正確同步，可以使用以下方法：

1. 使用synchronized關鍵字：

在需要同步的方法或代碼塊前加上synchronized關鍵字，可以確保同一時刻只有一個線程能夠訪問這個方法或代碼塊。例如：

public class MyRunnable implements Runnable {
    private final Object lock = new Object();

    @Override
    public void run() {
        synchronized (lock) {
            // 需要同步的代碼
        }
    }
}

2. 使用Lock接口：

Java提供了Lock接口及其實現類（如ReentrantLock）來實現更靈活的鎖機制。使用Lock可以顯式地獲取和釋放鎖，而不是使用synchronized關鍵字。例如：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyRunnable implements Runnable {
    private final Lock lock = new ReentrantLock();

    @Override
    public void run() {
        lock.lock(); // 獲取鎖
        try {
            // 需要同步的代碼
        } finally {
            lock.unlock(); // 釋放鎖
        }
    }
}

3. 使用Semaphore類：

Java提供了Semaphore類來實現信號量，可以用來控制對共享資源的訪問。例如，如果有一個需要同步的資源池，可以使用Semaphore來限制同時訪問資源的線程數量。

import java.util.concurrent.Semaphore;

public class MyRunnable implements Runnable {
    private final Semaphore semaphore = new Semaphore(3); // 允許最多3個線程同時訪問

    @Override
    public void run() {
        try {
            semaphore.acquire(); // 獲取許可
            // 需要同步的代碼
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release(); // 釋放許可
        }
    }
}

4. 使用CountDownLatch類：

Java提供了CountDownLatch類來實現倒計時門閂，可以用來控制線程的執行順序。例如，如果有一個主線程需要等待其他線程完成后再繼續執行，可以使用CountDownLatch。

import java.util.concurrent.CountDownLatch;

public class MyRunnable implements Runnable {
    private final CountDownLatch latch = new CountDownLatch(3); // 等待3個線程完成

    @Override
    public void run() {
        try {
            // 執行任務
            latch.countDown(); // 完成任務，計數器減1
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在主線程中調用latch.await()方法等待其他線程完成任務：

public class Main {
    public static void main(String[] args) throws InterruptedException {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread1 = new Thread(myRunnable);
        Thread thread2 = new Thread(myRunnable);
        Thread thread3 = new Thread(myRunnable);

        thread1.start();
        thread2.start();
        thread3.start();

        myRunnable.latch.await(); // 等待其他線程完成任務
    }
}

通過以上方法，可以實現Java多線程的同步。在實際應用中，可以根據具體需求選擇合適的同步策略。