Java 对象监视器

Question

我读到:

Object sync = new Object();

/* inter to monitor */
try {
    sync.wait();
} catch (InterruptedException ex) {

} finally {

}

/* our code*/
/* exit from monotir */
sync.notify();

就像

synchronize (sync) {
    /* our code*/
}

这是真的吗？

我在我的代码中尝试了这个，但它不起作用。

private Object data;
    private Object sync = new Object();

    public static void main(String[] args) {
        SimpleProducerConsumer pc = new SimpleProducerConsumer();
        new Thread(pc.new Producer()).start();
        new Thread(pc.new Consumer()).start();
    }

    public Object pop() {
        try {
            sync.wait();
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        System.out.println("Before");
        Object d = data;
        data = null;
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("pop");
        System.out.println("After");
        sync.notify();
        return d;
    }

    public void push(Object d) {
        try {
            sync.wait();
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        data = d;
        System.out.println("push");
        sync.notify();
    }

    class Producer implements Runnable {
        @Override
        public void run() {
            while (true) {
                push(new Object());
            }
        }
    }

    class Consumer implements Runnable {
        @Override
        public void run() {
            while (true) {
                pop();
            }
        }
    }

我的代码有什么问题？

Answer 1

不，sync.wait() 和 sync.notify() 远不是 sychronize (sync) { ... 的同义词和 ... 。

事实上，为了调用wait，您必须处于同步 block 中。

我将解释synchronize、wait 和notify 的概念，它们之间的区别将一目了然。

• 当线程进入synchronized (sync) { ... } block 时，它会获取 sync 监视器的锁(意味着锁被占用并且此时没有其他线程可以进入该 block )。

• 当线程调用sync.wait() 时，它会暂时释放sync 的锁。 (它正在等待某事发生。需要锁定才能发生的事情。)

• 线程调用 sync.notify() 以通知其他线程某事已发生，此时它们将恢复执行.

What is wrong with my code?

我假设你想确保如果两个线程试图弹出一些东西，他们应该避免做以下事情:

Thread 1              Thread 2
--------------------------------------
Object d = data;
                      Object d = data;
                      data = null;
data = null;
return d;
                      return d;

为避免这种情况，您需要确保 d = data 和 data = null 自动发生。

这可以通过做来实现

Object d;
synchronized (sync) {
    d = data;
    data = null;
}

(现在上面线程 1 中的第一条和第二条语句不能拆分。)

此外，您似乎希望 pop 被阻塞，即如果 d == null 它应该等待其他线程 push 一些东西.

这可以通过做来实现

synchronized (sync) {
    while (d == null)
        sync.wait();
}

并在 push 中执行 sync.notify()(同样在 synchronized block 中，涵盖推送中需要自动完成的所有事情方法)。

相关问题/进一步阅读:

• > The Java™ Tutorials: Guarded Blocks

• Why must wait() always be in synchronized block

  我在这里的回答给出了一个例子，说明如果 wait 和 notify 被允许在外部 一个同步块(synchronized block)。