java - 虚假唤醒、wait() 和 notifyAll()

Question

我有 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 中有有用的类？但是我没有看到任何有趣的东西...... :(

Answer 1

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 库之一作为起点。