0

问题如下，因为仅使用 down() 调用屏障，因此它将等待 n 个线程到达，然后在关键区域中一起执行所有 n 个线程，现在我如何通知调用barrier.down的线程它现在可以继续前进。我尝试在phase2( )之后添加notifyAll()但这不起作用。帮助？:)

public class cyclicBarrier {
    private int n;
    private int count;
    private semaphore mutex;
    private semaphore turnstile;
    private semaphore turnstile2;

    public cyclicBarrier(int n){
        this.n = n;
        this.count = 0;
        this.mutex = new semaphore(1);
        this.turnstile = new semaphore(0);
        this.turnstile2 = new semaphore(0);
    }

    public synchronized void down() throws InterruptedException{
        this.phase1(); //waits for n threads to arrive
        this.phase2(); //waits for n threads to execute
    }

    private synchronized void phase1() throws InterruptedException {
        this.mutex.down();
        this.count++;
        if(this.count == this.n){
            for(int i = 0; i < this.n; i++){
                this.turnstile.signal(); //when n threads received then move on to phase 2
            }
        }
        this.mutex.signal();
        this.turnstile.down(); //keeps waiting till I get n threads
    }

    private synchronized void phase2() throws InterruptedException {
        this.mutex.down();
        this.count--;
        if(this.count == 0){
            for(int i = 0; i < this.n; i++){
                this.turnstile2.signal(); //reset the barrier for reuse 
            }
        }
        this.mutex.signal();
        this.turnstile2.down(); //keeps waiting till n threads get executed
    }
}


public class semaphore {
    private int counter;

    public semaphore(int number){
        if (number > 0) {
            this.counter = number;
        }
    }

    public synchronized void signal(){
        this.counter++;
        notifyAll();
    }

    public synchronized void down() throws InterruptedException{
        while (this.counter <= 0){
            wait();
        }
        this.counter--;
    }
}
4

1 回答 1

1

我看到您正在使用The Little Book of Semaphores的解决方案。本书的一个要点是，您可以使用信号量作为唯一的协调原语来解决许多协调问题。使用同步来实现信号量是非常好的，因为这是正确执行它所必需的。然而，在解决一个应该用信号量解决的难题的方法中使用同步，它没有抓住重点。

另外，我认为它不适用于您的情况：您不会在this.turnstile.down()处陷入僵局吗？您阻塞了一个信号量，该信号量在对象和方法上持有一个排他锁（通过synchronized），这将允许该信号量被释放。

如上所述解决问题：您向线程发出信号，表明它们可以通过从barrier.down()返回来继续。您可以通过turntile.down()确保您不会过早返回。

旁白：信号量实现

您的信号量实现看起来是正确的，除了您只允许非负初始值，这至少是非标准的。这样做有什么我看不到的动机吗？如果您认为负初始值是错误的，为什么不抛出错误而不是默默地做其他事情呢？

旁白：其他同步原语

请注意，java 构造synchronized、.wait()和.notify()对应于Monitor协调原语。使用监视器（或其他协调原语）而不是信号量来解决难题可能是有益的，但我建议将这些努力分开。尝试使用Haskell 的 Software Transactional Memory解决难题时，我获得了一些乐趣。

旁白：关于可运行性

你说你已经尝试了一些东西，这表明你有一些代码可以让你运行问题中的代码。如果您包含该代码会很有帮助，因此我们也可以轻松运行它。我可能会检查我假设的死锁是否真的发生了。

于 2014-11-11T11:18:37.580 回答