3

我有 N 个线程在循环中执行这些操作：增加共享变量，检查共享变量值是否为 N（如果是，则将值放入队列）并执行 wait()。我还有一个检查 q 变量的威胁。如果 queue 为真，它会执行 notifyAll()。在那之后，N 个线程应该被唤醒，并进行另一次循环运行。但似乎有些线程在没有通知的情况下被唤醒。我读过关于虚假唤醒的文章，但我不知道应该对 while() 设置什么条件来检查它是否是虚假唤醒。

贝娄是我的代码示例（不一样，但含义非常相似）：

共享类在所有线程之间共享：

class Shared {
    volatile int v = 0;
}

我创建了 10 个线程并运行它们。

class NThreads implements Runnable {
    private Shared shared;
    private QThread q;
    static int N = 0; /* N - number of threads */

    public NThreads(QThread q, Shared shared) {
        this.q = q;
        this.shared = shared;
        ++N;
    }

    @Override
    public void run() {
        for (int i=0;i<1048575;++i) {
            doSomeCalculations();
            loop();
        }
    }

    private void loop() {
        synchronized (shared) {
            if (++shared.v == N) {
                shared.v = 0;
                synchronized (Q) {
                    q.q = true;
                }
                shared.wait();
            } else {
                shared.wait();
            }
        }
    }
}

只有一个 QThread 等待修改 q 然后调用 notifyAll();

class QThread implements Runnable {
    private Shared shared;
    volatile boolean q = false;

    public QThread(Shared shared) {
        this.shared = shared;
    }

    @Override
    public void run() {
        for (;;) {
            if (q) {
                synchronized (this) {
                    q = false;
                }
                synchronized (shared) {
                    shared.notifyAll();
                }
            }
            doSomethingElse();
            // or even: Thread.yield();
        }
    }
}

运行一切的主类：

class Main {
    public static void main(String[] args) {
        Shared shared = new Shared();
        QThread qt = new QThread(shared);
        NThread[] nt = new NThread[10];
        for (int i=0; i<nt.length; ++i) {
            nt[i] = new NThread(qt, shared);
        }
        Thread[] threads = new Thread[nt.length+1];
        threads[0] = new Thread(qt);
        for (int i=0; i<nt.length; ++i) {
            threads[1+i] = new Thread(nt[i]);
        }

        for (int i=0; i<threads.length; ++i) {
            threads[i].start();
        }

        for (int i=0; i<threads.length; ++i) {
            threads[i].join();
        }
    }
}

有时有线程（来自 NThreads）完成了它们的循环，但其他线程没有。我认为这是因为虚假唤醒。如何编写条件以获取虚假唤醒的蛋糕并确保所有线程都可以继续工作？

也许 java.util.concurrent 中有有用的类？但我没有看到任何有趣的东西...... :(

4

1 回答 1

3

Object.wait()的 JavaDocs讨论了虚假唤醒的可能性。它还提到您应该在离开等待循环之前检查外部条件的循环中使用 wait() 。

您需要稍微重构 loop() 方法来完成此操作

private void loop() {
    synchronized (shared) {
        shared.v++;
        while(shared.v < N) {
            shared.wait();
        }

        shared.v = 0;
        synchronized (Q) {
            q.q = true;
        } 
    }

最后，您可能应该找到一个内置的并发库，因为这些类型的东西很容易出错。我会以 Google 的 Guava、java.util.concurrency 或众多 Apache Commons 库之一作为起点。

于 2012-10-30T22:55:36.340 回答