的Java多线程同步

Question

我有一个麻烦与三个线程共享一个资源...

public class Subject{ 

     int i; 
     boolean valueSet1 = false; 
     boolean valueSet2 = true; 
     boolean valueSet3 = true; 

    void put(int i){ 

     while(valueSet1){ 
      try{ 
       wait(); 
       }catch(InterruptedException e){ 
        System.out.println("Producer thread interrupted"); 
       } 
      } 
      System.out.println("Producer thread wakesup"); 
      valueSet1=true; 
      valueSet2=false; 
      this.i=i;   
      System.out.println("Put: "+i); 
      notify(); 
     } 


    void makesquare(){ 

      int a; 
      while(valueSet2){ 
       try{ 
        System.out.println("Convertor thread goin to sleep"); 
        wait(); 
       }catch(InterruptedException e){ 
        System.out.println("Convertor thread interrupted"); 
       } 
      }  
      System.out.println("Convertor thread wakesup"); 
      valueSet2 = true; 
      valueSet3=false; 
      a = this.i; 
      this.i = a*a; 
      System.out.println("Made: "+i);   
      notify(); 
    } 

    void get(){ 

      while(valueSet3){ 
       try{ 
        System.out.println("Consumer thread goin to sleep");     
        wait(); 
       }catch(InterruptedException e){ 
        System.out.println("Consumer thread interrupted"); 
       } 
      } 
      System.out.println("Consumer thread wakesup"); 
      valueSet3 = true; 
      valueSet1 = false; 
      System.out.println("Got: "+i); 
      notify();  
    } 

    } 

    class Producer implements Runnable{ 

     Subject q;  
     Thread t; 
     String msg; 
     Producer(Subject q, String msg){ 
      this.q=q; 
      this.msg = msg; 
      t = new Thread(this, this.msg); 
     } 
     @Override 
     public void run(){ 
      int i=2; 
      while(true){ 
       synchronized(q){ 
       q.put(i++); 
       } 
      } 
     } 
    } 
    class Consumer implements Runnable{ 

     Subject q;  
     Thread t; 
     String msg; 
     Consumer(Subject q,String msg){ 
      this.q = q; 
      this.msg = msg; 
      t = new Thread(this, this.msg); 
     } 
     @Override 
     public void run(){ 
      while(true){ 
       synchronized(q){ 
       q.get(); 
       } 
      } 
     } 
    } 

    class Convertor implements Runnable{ 
     Subject q; 
     Thread t; 
     String msg; 
     Convertor(Subject q, String msg){ 
      this.q=q; 
      this.msg = msg; 
      t = new Thread(this, this.msg);  
     } 
     @Override 
     public void run(){ 
      while(true){ 
       synchronized(q){ 
       q.makesquare(); 
       } 
      } 
     } 
    } 

有三个线程的程序。一个线程产生另一个产生量的平方。而最后一个线程消耗平方的产品。它们都共享相同的对象。

public class Thread3way { 

     public static void main(String[] args) { 
      Subject q = new Subject(); 
      Producer P = new Producer(q, "producer"); 
      Convertor Cv = new Convertor(q, "convertor"); 
      Consumer Cs = new Consumer(q, "consumer"); 
      P.t.start(); 
      Cv.t.start(); 
      Cs.t.start(); 
     } 
    } 

Answer 1

你wait循环不是很正确，你需要不断循环，直到你的病情是真实的你做任何修改前。我会做这样的（使用State枚举让事情更清晰）：

public class Subject { 
    static enum State { EMPTY, WAITING_TO_SQUARE, WAITING_TO_GET }; 
    State state; 
    int value; 

    public synchronized void put(int i) { 
     while (state != State.EMPTY) { 
      try { 
       wait(); 
      }catch(InterruptedException e) { 
       System.out.println("Put interrupted"); 
      } 
     } 
     value = i; 
     state = State.WAITING_TO_SQUARE; 
    } 
} 

作为一个评论者指出的那样，你不需要同步两次，无论是synchronized(q)围绕Subject电话，或申报你的方法​​。你不需要两个。

无需使用Runnables明确，只是让Producer，Convertor和ConsumerThread小号直接。那么你不需要t字段，你可以像P.start()那样启动线程。

Answer 2

听起来对我来说就像你正在做某种管道，有3个阶段。为什么不享受ExecutorService的好处：

class ConvertorTask implements Runnable { 

    private int number; 
    private static ExecutorService consumer = Executors.newSingleThreadExecutor(); 

    public ConvertorTask(int number) { 
     this.number = number;  
    } 

    public void run() { 
     consumer.submit(new ConsumerTask(number * number)); 
    } 
} 

class ConsumerTask implements Runnable { 

    private int number; 

    public ConsumerTask(int number) { 
     this.number = number;  
    } 

    public void run() { 
     System.out.println(number); 
    } 
} 

class Producer implements Runnable { 

    private ExecutorService convertor = Executors.newSingleThreadExecutor(); 

    public void run() { 
     int i = 0; 
     while(true) {   
      convertor.submit(new ConvertorTask(i++)); 
     } 
    } 
} 

public class Test { 

    public static void main(String[] args) throws InterruptedException {   
     Thread t = new Thread(new Producer()); 
     t.start(); 
    } 
}