2つの独立したスレッドで待機して通知する方法はありますか？

Question

私はExecutorServiceを使用して2つの独立したスレッドを作成しました。今私はちょうど1つのスレッドがファイルにデータを書き込んで、別のスレッドがファイルにデータを書き込んでいるスレッドからの通知を受け取った後にそれを読むことを望みますが、出力には何も表示されません。

My code is: 
package threadingexamples; 

import java.io.BufferedReader; 
import java.io.BufferedWriter; 
import java.io.File; 
import java.io.FileReader; 
import java.io.FileWriter; 
import java.util.concurrent.Callable; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.TimeUnit; 

public class ThreadingExamples { 

public static void main(String[] args) throws InterruptedException { 
    ExecutorService es = Executors.newFixedThreadPool(2); 
    es.submit(new ForLoo1()); 
    es.submit(new ForLoop2()); 

    es.shutdown(); 
    es.awaitTermination(1, TimeUnit.DAYS); 

    System.exit(0); 
} 

} 

class ForLoo1 implements Callable<Object> { 

@Override 
public Object call() throws Exception { 

    System.out.println("I am writing content into file...."); 

    String s = "This is the content to write into a file"; 

    File file = new File("/home/f.txt"); 

    if (!file.exists()) { 
     file.createNewFile(); 
    } 

    FileWriter fw = new FileWriter(file); 
    BufferedWriter bw = new BufferedWriter(fw); 
    bw.write(s); 
    bw.close(); 
    System.out.println("Now you can read content from files..."); 
    notify(); 
    return null; 
} 

} 

class ForLoop2 implements Callable<Object> { 

    @Override 
    public Object call() throws Exception { 

     wait(); 
     System.out.println("Okay i am now going to read content of files..."); 

     BufferedReader br = new BufferedReader(new FileReader("f.txt")); 
     String str; 
     while ((str = br.readLine()) != null) { 
      str = str + ""; 
     } 
     System.out.println("I am done with reading....."); 
     System.out.println(str); 
     return null; 
    } 

} 

Answer 1

EDIT：これは何もしない例です。 CountDownLatchメソッドを使用してください。ほとんどのプログラムでnotifyまたはwaitを使用する必要はありません。また、以下のコメントを読んで、なぜこれが悪い考えであるかを正確に見てください。追加された​​ブロック（notifyとwaitを呼び出すために必要です）があっても、デッドロックにつながる可能性のある競合状態がまだあります。ForLoop2

---

あなたはほぼ手に入れました。上記のコードでwait()とnotify()を呼び出すと、別のオブジェクトで呼び出されています。これを試してください：

Object monitorObject = new Object(); 
es.submit(new ForLoo1(monitorObject)); 
es.submit(new ForLoop2(monitorObject)); 

... 


class ForLoop1 implements Callable<Object> { 
    private final Object monitorObject; 

    public ForLoop1(Object monitorObject) { 
     this.monitorObject = monitorObject; 
    } 

    @Override 
    public Object call() throws Exception { 

     ... 
     synchronized(monitorObject) { 
      monitorObject.notify(); 
     } 
    } 
} 

class ForLoop2 implements Callable<Object> { 
    private final Object monitorObject; 

    public ForLoop2(Object monitorObject) { 
     this.monitorObject = monitorObject; 
    } 

    @Override 
    public Object call() throws Exception { 

     synchronized(monitorObject) { 
      monitorObject.wait(); 
     } 
     ... 
    } 
} 

Answer 2

以下のコードで目的の効果を達成できます。 をForLoop2に呼び出すと、countDownが呼び出された後にスレッドが起動するのは、ForLoop1です。 CountDownLatchは、多彩な同期ツールです。

import java.io.BufferedReader; 
import java.io.BufferedWriter; 
import java.io.File; 
import java.io.FileReader; 
import java.io.FileWriter; 
import java.util.concurrent.Callable; 
import java.util.concurrent.CountDownLatch; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.TimeUnit; 

public class ThreadingExamples { 

public static void main(String[] args) throws InterruptedException { 
    final CountDownLatch cdl = new CountDownLatch(1); 
    ExecutorService es = Executors.newFixedThreadPool(2); 
    es.submit(new ForLoo1(cdl)); 
    es.submit(new ForLoop2(cdl)); 
    es.shutdown(); 
    es.awaitTermination(1, TimeUnit.DAYS); 

} 

} 

class ForLoo1 implements Callable<Object> { 
    CountDownLatch cdl; 
    public ForLoo1(CountDownLatch cdl){ 
     this.cdl=cdl; 
    } 

@Override 
public Object call() throws Exception { 

    System.out.println("I am writing content into file...."); 

    String s = "This is the content to write into a file"; 

    File file = new File("/home/f.txt"); 

    if (!file.exists()) { 
     file.createNewFile(); 
    } 

    FileWriter fw = new FileWriter(file); 
    BufferedWriter bw = new BufferedWriter(fw); 
    bw.write(s); 
    bw.close(); 
    System.out.println("Now you can read content from files..."); 
    cdl.countDown(); 
    return null; 
} 

} 

class ForLoop2 implements Callable<Object> { 
    CountDownLatch cdl; 
    public ForLoop2(CountDownLatch cdl){ 
     this.cdl=cdl; 
    } 

    @Override 
    public Object call() throws Exception { 

     cdl.await(); 
     System.out.println("Okay i am now going to read content of files..."); 

     BufferedReader br = new BufferedReader(new FileReader(new File("/home/f.txt"))); 
     String str; 
     System.out.println("I am done with reading....."); 
     while ((str = br.readLine()) != null) { 
      System.out.println(str); 
     } 

     return null; 
    } 

} 

Answer 3

これは、将来を使用して行うことができます。最初のタスクを送信すると、タスクが完了すると、2番目のタスクが最初のタスクの戻り値を取得するために使用できるFutureが返されます。 futureを受け取るCallableタスクは、getメソッドが結果を受け取るまでブロックします。

package threadingexamples; 

import java.io.BufferedReader; 
import java.io.BufferedWriter; 
import java.io.File; 
import java.io.FileReader; 
import java.io.FileWriter; 
import java.util.concurrent.Callable; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.TimeUnit; 
import java.util.concurrent.Future; 

public class ThreadingExamples { 

    public static void main(String[] args) throws InterruptedException { 

     ExecutorService es = Executors.newFixedThreadPool(2); 
     Future<Object> future = es.submit(new ForLoo1()); 
     es.submit(new ForLoop2(future)); 

     es.shutdown(); 
     es.awaitTermination(1, TimeUnit.DAYS); 
    } 

} 

class ForLoo1 implements Callable<Object> { 

    @Override 
    public Object call() throws Exception { 

     System.out.println("I am writing content into file...."); 

     String s = "This is the content to write into a file"; 

     File file = new File("/home/f.txt"); 

     if (!file.exists()) { 
      file.createNewFile(); 
     } 

     FileWriter fw = new FileWriter(file); 
     BufferedWriter bw = new BufferedWriter(fw); 
     bw.write(s); 
     bw.close(); 
     System.out.println("Now you can read content from files..."); 
     return "ok"; 
    } 
} 

class ForLoop2 implements Callable<Object> { 

    private Future<Object> future; 

    public ForLoop2(Future<Object> future) { 
     this.future = future; 
    } 

    @Override 
    public Object call() throws Exception { 
     System.out.println("in ForLoop2, "); 
     Object ok = future.get(); 

     System.out.println("Okay i am now going to read content of files..."); 

     BufferedReader br = new BufferedReader(new FileReader("f.txt")); 
     String str; 
     while ((str = br.readLine()) != null) { 
      str = str + ""; 
     } 
     System.out.println("I am done with reading....."); 
     System.out.println(str); 
     return null; 
    } 
} 

また、あなたは、各呼び出し可能のコンストラクタに渡すことを、BlockingQueueのを使用することができます。私は、null以外の値を返すために、最初の呼び出し可能に変更しました。 1つのCallableはキューにエントリを配置し、もう1つはそこからエントリを読み込みます。これは、スレッド間で複数のメッセージが渡されることが予想される状況に適しています。ただし、同じ原則です。タスクにではなく、データ構造に待機/通知コードを挿入します。