Javaスレッドに別のスレッドの出力を待機させる方法は？

私は、application-logic-threadとdatabase-access-threadを使用してJavaアプリケーションを作成しています。どちらもアプリケーションの存続期間全体にわたって持続し、両方を同時に実行する必要があります（1つはサーバーと通信し、1つはユーザーと通信します。アプリが完全に起動すると、両方が動作する必要があります）。

ただし、起動時には、アプリスレッドが最初にdbスレッドの準備ができるまで待機することを確認する必要があります（現在、カスタムメソッドのポーリングによって決定されdbthread.isReady()ます）。アプリケーションのスレッドがdbスレッドの準備ができるまでブロックしてもかまいません。

Thread.join() 解決策のようには見えません-dbスレッドはアプリのシャットダウン時にのみ終了します。

while (!dbthread.isReady()) {} 一種の作品ですが、空のループは多くのプロセッササイクルを消費します。

他のアイデアは？ありがとう。

マルチスレッディングの魔法の世界に入る前に、SunのJava同時実行のようなチュートリアルを実行することをお勧めします。

多くの優れた書籍も出ています（「Javaでの並行プログラミング」、「Javaの並行性の実践」のグーグル。

あなたの答えを得るには：

を待機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などです。Java5以降、java.util.concurrentパッケージとサブパッケージには気の利いた並行処理クラスがたくさんあります。並行性を理解したり、良い本を入手したりするには、オンラインで資料を見つける必要があります。

CountDownLatchを1のカウンターで使用します。

CountDownLatch latch = new CountDownLatch(1);

アプリスレッドで

latch.await();

dbスレッドで、完了したら、次を実行します-

latch.countDown();

要件::

1. 前のスレッドが終了するまで次のスレッドの実行を待機します。
2. 時間の消費に関係なく、次のスレッドは前のスレッドが停止するまで開始してはなりません。
3. シンプルで使いやすいものでなければなりません。

回答::

@ java.util.concurrent.Future.get（）ドキュメントを参照してください。

future.get（）必要に応じて計算が完了するのを待ってから、結果を取得します。

仕事完了!! 以下の例を参照してください

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同時実行による幸運。

正解の多くが、簡単な例なし...ここでは、使用するどのように簡単でシンプルな方法です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

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();

編集：

（この投稿を編集して申し訳ありませんが、このコードには非常に悪い競合状態があり、コメントするのに十分な評判がありません）

これは、await（）の後にsignal（）が呼び出されることが100％確実である場合にのみ使用できます。これが、WindowsイベントなどのJavaオブジェクトを使用できない大きな理由の1つです。

コードがこの順序で実行される場合：

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

その後、スレッド2は永久に待機します。これは、Object.notify（）が現在実行中のスレッドの1つだけを起こすためです。後で待機しているスレッドは起こされません。これは、イベントが機能することを期待する方法とは大きく異なります。イベントは、a）待機するか、b）明示的にリセットされるまで通知されます。

注：ほとんどの場合、notifyAll（）を使用する必要がありますが、これは上記の「永久に待機する」問題には関係ありません。

CountDownLatchクラスをjava.util.concurrentパッケージから試してみてください。これにより、高レベルの同期メカニズムが提供され、低レベルのものよりもエラーが発生しにくくなります。

これは、2つのスレッド間で共有されるExchangerオブジェクトを使用して行うことができます。

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

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

そして2番目のスレッドで：

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

}

他の人が言ったように、この気軽なコードをコピーして貼り付けないでください。最初にいくつか読んでください。

パッケージのFutureインターフェースは、java.lang.concurrent別のスレッドで計算された結果へのアクセスを提供するように設計されています。

この種のことを行う既製の方法については、FutureTaskとExecutorServiceをご覧ください。

並行性とマルチスレッドに興味がある人には、Java Concurrency In Practiceを読むことを強くお勧めします。それは明らかにJavaに集中していますが、他の言語で作業する人にとっても多くの肉があります。

すばやく簡単なものが必要な場合は、whileループ内にThread.sleep（）呼び出しを追加するだけです。データベースライブラリが変更できないものである場合、他に簡単な解決策はありません。待機期間を設ける準備ができるまでデータベースをポーリングしても、パフォーマンスが低下することはありません。

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

エレガントなコードとは言えないかもしれませんが、作業は完了です。

データベースコードを変更できる場合は、他の回答で提案されているようにmutexを使用することをお勧めします。

これはすべての言語に適用されます：

イベント/リスナーモデルが必要です。特定のイベントを待機するリスナーを作成します。イベントはワーカースレッドで作成（または通知）されます。これにより、現在のソリューションのように、条件が満たされているかどうかを常にポーリングするのではなく、シグナルが受信されるまでスレッドがブロックされます。

状況は、デッドロックの最も一般的な原因の1つです。発生したエラーに関係なく、他のスレッドにシグナルを送信するようにしてください。例-アプリケーションが例外をスローし、メソッドが呼び出されて、完了したことを他のユーザーに通知しない場合。これにより、他のスレッドが「ウェイクアップ」しないようになります。

ケースを実装する前に、このパラダイムをよりよく理解するために、イベントとイベントハンドラーの使用の概念を検討することをお勧めします。

または、mutex-を使用してブロッキング関数呼び出しを使用できます。これにより、リソースが解放されるまでスレッドが待機します。これを行うには、次のような適切なスレッド同期が必要です。

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

あるスレッドでブロッキングキューから読み取り、別のスレッドで書き込むことができます。

以来

1. join() 除外されました
2. あなたはすでにCountDownLatchを使用しており、
3. Future.get（）はすでに他の専門家によって提案されています、

他の代替案を検討できます。

1. からinvokeAllExecutorService

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

   指定されたタスクを実行し、すべてが完了すると、ステータスと結果を保持するFutureのリストを返します。

2. ForkJoinPoolまたはnewWorkStealingPool from Executors（Java 8リリース以降）

   使用可能なすべてのプロセッサをターゲットの並列処理レベルとして使用して、ワークスチールスレッドプールを作成します。

このアイデアは適用できますか？CountdownLatchesまたはSemaphoresを使用すると完璧に機能しますが、インタビューの最も簡単な答えを探している場合、これは当てはまると思います。