Ожидание потока во время цикла

Мое приложение имеет 1 глобальный драйвер, который отвечает за выполнение низкоуровневой работы. Затем у меня есть 2 потока, оба из которых используют бесконечные циклы, чтобы выполнить некоторую работу. Мой вопрос заключается в том, как разрешить 1 поток использовать драйвер как можно больше, но дает возможность второму потоку использовать его, когда это необходимо.

Чтобы уточнить, код, который у меня есть, выглядит следующим образом:

public class Game {
    private static final Object LOCK = new Object();
    private static final Logger LOGGER = Logger.getLogger(Game.class);

    private WebDriverController controller;

    public Game(WebDriverController controler) {
        this.controller = controller;
    }

    public void startThreadA() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    synchronized (LOCK) {
                        controller.doSomethingA();
                    }
                }
            }
        }).start();
    }

    public void startThreadB() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    ...
                    ...
                    synchronized (LOCK) {
                        controller.doSomethingB();
                    }
                    ...
                    ...
                }
            }
        }).start();
    }
}

Логика состоит в том, чтобы позволить первому потоку выполнить doSomethingA() как можно больше, при этом второй поток doSomethingA() только блокировку для выполнения небольших задач и затем возвращает блокировку в первый поток.

Используя этот код, первый поток будет постоянно использовать контроллер, чтобы делать то, что ему нужно, тогда как второй поток застревает в своем синхронизированном блоке. Способ, которым я в настоящее время исправлен, заключается в добавлении паузы к первому потоку, чтобы дать второму потоку возможность получить блокировку следующим образом:

public void startThreadA() {
    new Thread(new Runnable() {
        @Override
        public void run() {
            while (true) {
                synchronized (LOCK) {
                    controller.doSomethingA();
                }
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    LOGGER.error(null, e);
                }
            }
        }
    }).start();
}

Это работает точно так, как предполагалось, но это кажется неправильным. Я не доволен ручной паузой после каждой итерации, особенно если второй поток не нуждается в блокировке, поскольку он тратит время.

Что я могу заменить на паузу, чтобы сделать это более эффективным?