Java 中的synchronized()/wait()/notifyAll() 是做什么的？

Question

可能的重复：
Java 同步

我正在阅读《Beginning Android Games》一书。

它经常使用 synchronized() 但我不太明白它的作用。我已经很长时间没有使用Java了，我不确定我是否使用过多线程。

在 Canvas 示例中，它使用 synchronized(this)。然而，在 OpenGL ES 示例中，它创建一个名为 stateChanged 的对象，然后使用 synchronized(stateChanged)。当游戏状态发生变化时，它会调用 stateChanged.wait() ，然后调用 stateChanged.notifyAll();

一些代码：

    Object stateChanged = new Object();

    //The onPause() looks like this:
    public void onPause()
        {
            synchronized(stateChanged)
            {
                if(isFinishing())
                    state = GLGameState.Finished;
                else
                    state = GLGameState.Paused;

                while(true)
                {
                    try
                    {
                        stateChanged.wait();
                        break;
                    } catch(InterruptedException e)
                    {
                    }
                }
            }
        }
//The onDrawSurface looks like this:
public void onDrawFrame(GL10 gl)
    {
        GLGameState state = null;
        synchronized(stateChanged)
        {
            state = this.state;
        }

        if(state == GLGameState.Running)
        {

        }

        if(state == GLGameState.Paused)
        {
            synchronized(stateChanged)
            {
                this.state = GLGameState.Idle;
                stateChanged.notifyAll();
            }
        }

        if(state == GLGameState.Finished)
        {
            synchronized(stateChanged)
            {
                this.state = GLGameState.Idle;
                stateChanged.notifyAll();
            }
        }
    }

//the onResume() looks like this:
synchronized(stateChanged)
        {
            state = GLGameState.Running;
            startTime = System.nanoTime();
        }

Answer 1

synchronized 关键字用于保持变量或方法的线程安全。如果将变量包装在同步块中，如下所示：

synchronized(myVar) {
    // Logic involing myVar
}

那么当同步块内的逻辑正在运行时，从另一个线程修改 myVar 值的任何尝试都将等待该块完成执行。它确保进入该块的值在该块的生命周期中都是相同的。

Answer 2

这个 Java 教程 可能可以帮助您了解在对象确实如此。

当调用object.wait()时，它将释放该对象上持有的锁（当您说synchronized(object)时会发生这种情况），并冻结线程。然后，该线程将等待，直到由单独的线程调用 object.notify() 或 object.notifyAll()。一旦发生其中一个调用，它将允许由于 object.wait() 而停止的任何线程继续。这不意味着调用object.notify()或object.notifyAll()的线程将冻结并将控制权传递给等待线程，这只是意味着这些等待线程现在能够继续，而之前却不能。

Answer 3

像这样使用时：

private synchronized void someMehtod()

您会得到以下效果：

1. 首先，同一对象上的同步方法的两次调用不可能交错。当一个线程正在执行对象的同步方法时，调用同一对象的同步方法的所有其他线程都会阻塞（挂起执行），直到第一个线程完成该对象。

2. 其次，当同步方法退出时，它会自动与同一对象的同步方法的任何后续调用建立发生之前关系。这保证了对象状态的更改对所有线程都可见。

（取自此处）

当您使用同步代码块：

private void someMethod() {
  // some actions...

  synchronized(this) {
    // code here has synchronized access
  }

  // more actions...
}

如此处所述

Answer 4

Java（Android 的基础）可以在多个线程下运行，这些线程可以利用多个 CPU 核心。多线程意味着您可以让 Java 在同一时刻执行两个进程。如果您需要确保一次只能由一个线程操作一段代码或方法，则可以同步该代码块。

这是 Oracle 的官方 Java 解释

重要的是要知道使用同步会产生处理器/IO 成本，并且您只想在需要时使用它。研究哪些 Java 类/方法是线程安全的也很重要。例如，++ 递增运算符不能保证线程安全，而您可以轻松创建使用 += 1 递增值的同步代码块。

Answer 5

只有一个线程可以处于活动状态并且在给定对象同步的块内。
调用 wait stop 会放弃此权利并停用当前线程，直到有人调用 notification(all)()
然后，不活动的线程开始想要再次在同步块中运行，但与所有其他需要它的线程受到同等对待。只有以某种方式选择的一个（程序员不能影响也不依赖于哪一个）真正能够到达那里。

Answer 6

java中的synchronized关键字有两个用途。

第一个含义是所谓的临界区，即可以被一个线程同时访问的部分代码。您传递给 synchronized 的对象允许某种命名：如果一个代码在 synchronized(a) 中运行，它就无法访问 synchronized(a) 中的其他块) 但可以将代码块访问到 synchronized(b) 中。

另一个问题是线程间通信。线程可以等待，直到其他线程通知它。 wait 和notify 都必须写入synchronized 块中。

这是一个非常简短的描述。我建议您搜索一些有关多线程的教程并阅读它。

Answer 7

关键字synchronized与等待和通知操作一起形成一个非阻塞条件监视器，用于协调多个线程的构造。