Question

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

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

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

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（），它在离开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库中的一个作为起点。

虚假唤醒，wait（）和notifyAll（）

1 个答案: