Как заставить поток Java ожидать вывода другого потока?

Используйте CountDownLatch со счетчиком 1.

CountDownLatch latch = new CountDownLatch(1);

Теперь в потоке приложения делают -

latch.await();

В потоке дб, после того, как Вы сделаны, сделайте -

latch.countDown();

будущее интерфейс от java.lang.concurrent пакет разработан для обеспечения доступа к результатам, вычисленным в другом потоке.

Смотрят на FutureTask и ExecutorService для готового способа сделать такого рода вещь.

я настоятельно рекомендовал бы читать Параллелизм Java На практике любому заинтересованному параллелизмом и многопоточностью. Это, очевидно, концентрируется на Java, но существует много сути для кого-либо работающего на других языках также.

Вы могли сделать это с помощью Обменник объект, совместно использованный двумя потоками:

private Exchanger<String> myDataExchanger = new Exchanger<String>();

// Wait for thread's output
String data;
try {
  data = myDataExchanger.exchange("");
} catch (InterruptedException e1) {
  // Handle Exceptions
}

И во втором потоке:

try {
    myDataExchanger.exchange(data)
} catch (InterruptedException e) {

}

, Поскольку другие сказали, не берите это беззаботное и просто код вставки копии. Сделайте некоторое чтение сначала.

Если Вы хотите что-то быстрое и грязное, можно просто добавить Thread.sleep () вызов в цикле с условием продолжения. Если библиотека базы данных - что-то, что Вы не можете изменить, то нет действительно никакого другого легкого решения. Опрос базы данных до готов с периодом ожидания, не уничтожит производительность.

while (!dbthread.isReady()) {
  Thread.sleep(250);
}

Едва что-то, что Вы могли назвать изящный код, но сделали работу.

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

Это относится ко всем языкам:

Вы хотите иметь модель события/слушателя. Вы создаете слушателя для ожидания конкретного события. Событие было бы создано (или сообщено) в Вашем рабочем потоке. Это заблокирует поток, пока сигнал не будет получен вместо того, чтобы постоянно опросить, чтобы видеть, соблюдают ли условие, как решение Вы в настоящее время имеете.

Ваша ситуация является одной из наиболее распространенных причин для мертвых блокировок - удостоверяются, что Вы предупреждаете о другом потоке независимо от ошибок, которые, возможно, произошли. Пример - если Ваше приложение выдает исключение - и никогда не называет метод для передачи сигналов о другом, что вещи завершились. Это сделает его так, другой поток никогда не 'просыпается'.

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

, Кроме того, можно использовать блокирующийся вызов функции с помощью взаимного исключения - который заставит поток ожидать ресурса, чтобы быть свободным. Чтобы сделать это, Вам нужна хорошая синхронизация потока - такая как:

Thread-A Locks lock-a
Run thread-B
Thread-B waits for lock-a
Thread-A unlocks lock-a (causing Thread-B to continue)
Thread-A waits for lock-b 
Thread-B completes and unlocks lock-b

Попробуйте класс CountDownLatch из java.util.concurrent пакет, который обеспечивает высокоуровневые механизмы синхронизации, которые намного менее подвержены ошибкам, чем любой низкоуровневый материал.

public class ThreadEvent {

    private final Object lock = new Object();

    public void signal() {
        synchronized (lock) {
            lock.notify();
        }
    }

    public void await() throws InterruptedException {
        synchronized (lock) {
            lock.wait();
        }
    }
}

Используйте этот класс следующим образом:

Создайте ThreadEvent:

ThreadEvent resultsReady = new ThreadEvent();

В методе ожидаются результаты:

resultsReady.await();

И в методе, который создает результаты после того, как были созданы все результаты:

resultsReady.signal();

РЕДАКТИРОВАТЬ:

(Извините за редактирование этого сообщения, но этот код имеет очень плохое состояние гонки, и у меня недостаточно репутации для комментариев)

Вы можете использовать это, только если вы на 100% уверены, что signal () вызывается после await (). Это одна из основных причин, по которой вы не можете использовать объект Java, например, Windows Events.

Если код выполняется в следующем порядке:

Thread 1: resultsReady.signal();
Thread 2: resultsReady.await();

, то поток 2 будет ждать вечно . Это потому, что Object.notify () пробуждает только один из запущенных в данный момент потоков. Поток, ожидающий позже, не пробуждается. Это сильно отличается от того, как я ожидаю, что события будут работать, когда событие сигнализируется до тех пор, пока а) не будет выполнено ожидание или б) явно не сброшено.

Примечание. В большинстве случаев следует использовать notifyAll (),