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

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

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

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

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

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

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

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

Есть также ряд хороших книг (google для «Параллельное программирование на Java», «Java Concurrency in Practice».

Чтобы найти ответ:

В вашем коде, который должен ждать dbThread, у вас должно быть что-то вроде этого:

//do some work
synchronized(objectYouNeedToLockOn){
    while (!dbThread.isReady()){
        objectYouNeedToLockOn.wait();
    }
}
//continue with work after dbThread is ready

В вашем методе dbThread вам нужно будет сделать что-то вроде этого:

//do db work
synchronized(objectYouNeedToLockOn){
    //set ready flag to true (so isReady returns true)
    ready = true;
    objectYouNeedToLockOn.notifyAll();
}
//end thread run method here

objectYouNeedToLockOn, который я использую в этих примерах, предпочтительно является объектом, которым вам нужно управлять одновременно из каждого потока, или вы можете создать отдельный Object для этой цели (я бы не рекомендовал синхронизировать сами методы):

private final Object lock = new Object();
//now use lock in your synchronized blocks

Чтобы углубить ваше понимание:
Есть и другие (иногда более эффективные) способы сделать это, например: с CountdownLatches и т. д. Начиная с Java 5, в пакете и подпакетах java.util.concurrent имеется множество изящных классов параллелизма. Вам действительно нужно найти в Интернете материал, чтобы познакомиться с параллелизмом или получить хорошую книгу.

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

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

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. Если вы не можете изменить библиотеку базы данных, то другого простого решения действительно нет. Опрос базы данных до ее готовности с периодом ожидания не убьет производительность.

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

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

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

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

Взгляните на FutureTask и ExecutorService, чтобы найти готовый способ делать такие вещи.

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

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

CountDownLatch latch = new CountDownLatch(1);

Теперь в ветке приложения:

latch.await();

В потоке db после того, как вы закончите, сделайте -

latch.countDown();

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.

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

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

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

Примечание. В большинстве случаев вам следует использовать notifyAll (), но это не имеет отношения к описанной выше проблеме «ждать вечно».

Требование:

1. To wait execution of next thread until previous finished.
2. Next thread must not start until previous thread stops, irrespective of time consumption.
3. It must be simple and easy to use.

Отвечать ::

@See java.util.concurrent.Future.get() doc.

future.get() Waits if necessary for the computation to complete, and then retrieves its result.

Дело сделано!! См. Пример ниже

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

import org.junit.Test;

public class ThreadTest {

    public void print(String m) {
        System.out.println(m);
    }

    public class One implements Callable<Integer> {

        public Integer call() throws Exception {
            print("One...");
            Thread.sleep(6000);
            print("One!!");
            return 100;
        }
    }

    public class Two implements Callable<String> {

        public String call() throws Exception {
            print("Two...");
            Thread.sleep(1000);
            print("Two!!");
            return "Done";
        }
    }

    public class Three implements Callable<Boolean> {

        public Boolean call() throws Exception {
            print("Three...");
            Thread.sleep(2000);
            print("Three!!");
            return true;
        }
    }

    /**
     * @See java.util.concurrent.Future.get() doc
     *      <p>
     *      Waits if necessary for the computation to complete, and then
     *      retrieves its result.
     */
    @Test
    public void poolRun() throws InterruptedException, ExecutionException {
        int n = 3;
        // Build a fixed number of thread pool
        ExecutorService pool = Executors.newFixedThreadPool(n);
        // Wait until One finishes it's task.
        pool.submit(new One()).get();
        // Wait until Two finishes it's task.
        pool.submit(new Two()).get();
        // Wait until Three finishes it's task.
        pool.submit(new Three()).get();
        pool.shutdown();
    }
}

Вывод этой программы:

One...
One!!
Two...
Two!!
Three...
Three!!

Вы можете видеть, что до завершения задачи требуется 6 секунд, что больше, чем у другого потока. Итак, Future.get () ждет, пока задача не будет выполнена.

Если вы не используете future.get (), он не дожидается завершения и выполняет в зависимости от потребления времени.

Удачи с параллелизмом Java.

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

Эту идею можно применить ?. Если вы используете CountdownLatches или Semaphores, отлично работает, но если вы ищете самый простой ответ для интервью, я думаю, что это применимо.

С

1. join() исключен
2. вы уже используете CountDownLatch и
3. Future.get () уже предлагается другими экспертами,

Вы можете рассмотреть другие альтернативы:

1. invokeAll из ExecutorService

   invokeAll(Collection<? extends Callable<T>> tasks)
   

   Executes the given tasks, returning a list of Futures holding their status and results when all complete.

2. ForkJoinPool или newWorkStealingPool из Executors (начиная с версии Java 8)

   Creates a work-stealing thread pool using all available processors as its target parallelism level.

Множество правильных ответов, но без простого примера. Вот простой и легкий способ использования CountDownLatch:

//inside your currentThread.. lets call it Thread_Main
//1
final CountDownLatch latch = new CountDownLatch(1);

//2
// launch thread#2
new Thread(new Runnable() {
    @Override
    public void run() {
        //4
        //do your logic here in thread#2

        //then release the lock
        //5
        latch.countDown();
    }
}).start();

try {
    //3 this method will block the thread of latch untill its released later from thread#2
    latch.await();
} catch (InterruptedException e) {
    e.printStackTrace();
}

//6
// You reach here after  latch.countDown() is called from thread#2