用一对标志来实现繁忙的等待

Question

我想用2个标志来实现一个繁忙的等待机制。我得到了一个僵局，但只是无法理解为什么...它看起来好像它应该工作...

对于长代码抱歉，这是我成功做到的最短代码。

package pckg1; 

public class MainClass { 

public static void main(String[] args) { 
    Buffer b = new Buffer(); 
    Producer prod = new Producer(b); 
    Consumer cons = new Consumer(b); 

    cons.start(); 
    prod.start(); 
} 
} 

class Producer extends Thread { 
private Buffer buffer; 

public Producer(Buffer buffer1) { 
    buffer = buffer1; 
} 

public void run() { 
    for (int i = 0; i < 60; i++) { 
     while (!buffer.canUpdate) 
      ; 
     buffer.updateX(); 
     buffer.canUpdate = false; 
     buffer.canUse = true; 
    } 
} 
} 

class Consumer extends Thread { 
private Buffer buffer; 

public Consumer(Buffer buffer1) { 
    buffer = buffer1; 
} 

public void run() { 
    for (int i = 0; i < 60; i++) { 
     while (!buffer.canUse) 
      ; 
     buffer.consumeX(); 
     buffer.canUse = false; 
     buffer.canUpdate = true; 
    } 
} 
} 

class Buffer { 
private int x; 
public boolean canUpdate; 
public boolean canUse; 

public Buffer() { 
    x = 0; 
    canUpdate = true; 
} 

public void updateX() { 
    x++; 
    System.out.println("updated to " + x); 

} 

public void consumeX() { 
    System.out.println("used " + x); 
} 
} 

Answer 1

我建议所有有关Buffer的逻辑应该进入该类。

此外，访问（和修改）标志必须受到保护，如果有2个或更多有权访问它。这就是为什么我把synchronised的2种方法。

class Buffer { 
private int x; 
private boolean canUpdate; 
private boolean canUse; 

public Buffer() { 
    x = 0; 
    canUpdate = true; 
} 

public synchronised void updateX() { 
    x++; 
    System.out.println("updated to " + x); 
    canUpdate = false; 
    canUse = true; 
} 

public synchronised void consumeX() { 
    System.out.println("used " + x); 
    canUpdate = true; 
    canUse = false; 
} 

    public synchronised boolean canUse() { 
     return canUse; 
    } 
    public synchronised boolean canUpdate() { 
     return canUpdate; 
    } 
} 

此外，取出canUpdate和canUse从Producer和Consumer类写入和替换读取（在conditons）与方法。

另外，在等待循环中引入一些Thread.sleep(100)会很有用。