在对象类中放置wait（），notify（）方法背后的概念

Question

我只是很难有时间去了解背后把概念wait()在Object类。对于这个问题，为了考虑是否wait()和notifyAll()在Thread类。

class Reader extends Thread {
    Calculator c;
    public Reader(Calculator calc) {
        c = calc;
    }

    public void run() {
        synchronized(c) {                              //line 9
        try {
            System.out.println("Waiting for calculation...");
            c.wait();
        } catch (InterruptedException e) {}
            System.out.println("Total is: " + c.total);
        }
    }

    public static void main(String [] args) {
        Calculator calculator = new Calculator();
        new Reader(calculator).start();
        new Reader(calculator).start();
        new Reader(calculator).start();
        calculator.start();
    }
}

class Calculator extends Thread {
    int total;
    public void run() {
        synchronized(this) {                     //Line 31
            for(int i=0;i<100;i++) {
                total += i;
            }
             notifyAll();
        }
    } 
}

我的问题是，它可以带来什么变化？在第9行中，我们获取对对象c的锁定，然后执行满足等待条件的等待，该条件是我们需要在使用wait之前获取对对象的锁定的等待条件，对于notifyAll的情况，我们在第31行获取了对Calculator对象的锁定。

Answer 1

我只是很难理解将wait（）放在对象类中的概念，出于这个问题，请考虑一下，好像wait（）和notifyAll（）在线程类中一样

在Java语言中，您要wait()在一个特定的实例上Object–确切地说，是分配给该对象的监视器。如果要向正在等待该特定对象实例的一个线程发送信号，则可以调用notify()该对象。如果要向正在等待该对象实例的所有线程发送信号，请notifyAll()在该对象上使用。

如果wait()和notify()在Thread相反的位置，则每个线程将必须知道其他每个线程的状态。线程1如何知道线程2正在等待访问特定资源？如果需要调用thread1，thread2.notify()则必须以某种方式找出thread2正在等待的线程。线程需要某种机制来注册它们所需的资源或操作，以便其他线程可以在就绪或可用时发出信号。

在Java中，对象本身是线程之间共享的实体，该实体允许线程彼此通信。线程彼此之间没有特定的知识，它们可以异步运行。他们运行，然后锁定，等待并通知 对象
要访问的 对象 。他们不了解其他线程，也不需要知道它们的状态。他们不需要知道正在等待资源的是thread2
－他们只是通知资源，无论正在等待的人（如果有人）都将得到通知。

然后，在Java中，我们将对象用作线程之间的同步，互斥体和通信点。我们在对象上进行同步，以获取对重要代码块的互斥访问并同步内存。如果我们在等待某种条件的改变（即某些资源可用），我们就在一个对象上。如果我们想唤醒睡眠线程，则通知对象。

// locks should be final objects so the object instance we are synchronizing on,
// never changes
private final Object lock = new Object();
...
// ensure that the thread has a mutex lock on some key code
synchronized (lock) {
    ...
    // i need to wait for other threads to finish with some resource
    // this releases the lock and waits on the associated monitor
    lock.wait();
    ...
    // i need to signal another thread that some state has changed and they can
    // awake and continue to run
    lock.notify();
}

程序中可以有任意数量的锁定对象-
每个锁定对象都锁定特定的资源或代码段。您可能有100个锁对象和只有4个线程。当线程运行程序的各个部分时，它们可以独占访问锁定对象之一。同样，他们不必知道其他线程的运行状态。

这使您可以根据需要任意扩展或缩小软件中运行的线程数。您发现这4个线程在外部资源上阻塞过多，因此可以增加数量。过分用力推动服务器，然后减少正在运行的线程数。锁定对象确保线程之间的互斥和通信与正在运行的线程数无关。