为什么java thread wait（）在这里只能在有时间限制的情况下工作？

我试图熟悉SCJP的Java线程，我有一个问题

在下面编写的代码中，我只是创建了： 两个可运行的 通用数据存储器（阵列）和 一种synchronized write（）方法，用于连续地用数据填充它，并为顺序中的每个可运行（a和B）留下一个字母作为标记

我知道代码很粗糙，可以写得更好，但我在寻找线程的寓意

现在，当我运行它时，它不会终止，结果会在以下位置停止：

还不错。 A0

但是，当我将wait（）更改为wait（100）时，它的工作方式是从0到9进行精细计数，并正常终止。有人能给我解释一下背后的原因吗

多谢各位

public class ArrayThreads {

Object[] array = new Object[10];
boolean isA = true;

    int position = 0;

    int getIndex(){
        return position;
    }



class ThreadA implements Runnable{

            synchronized void write(String value){
                    while(!isA){
            try {
                wait();
            } catch (InterruptedException ex) {
                System.out.println("An error in" + value);
                ex.printStackTrace();
            }
        }
        array[position] = value + position;
        System.out.println(array[position]);
        position++;
        isA = !isA;
        notify();
    }

    public void run() {
        while(getIndex()<array.length){
            if (getIndex()==9) return;
            else
        write("A");}
    }
}

    class ThreadB implements Runnable{

                synchronized void write(String value){
                    while(isA){
            try {
                wait();
            } catch (InterruptedException ex) {
                System.out.println("An error in" + value);
                ex.printStackTrace();
            }
        }
        array[position] = value + position;
        System.out.println(array[position]);
        position++;
        isA = !isA;
        notify();
    }

    public void run() {
        while(getIndex()<array.length){
            if (getIndex()==9) return;
            else
        write("B");}
    }
}

    public static void main(String[] args){
        ArrayThreads threads = new ArrayThreads();
        Thread threadA = new Thread(threads.new ThreadA());
        Thread threadB = new Thread(threads.new ThreadB());
        System.out.println("Still good");

        threadB.start();
        threadA.start();
    }

公共类数组读取{
Object[]数组=新对象[10]；
布尔值isA=真；
int位置=0；
int getIndex（）{
返回位置；
}
类ThreadA实现可运行的{
同步无效写入（字符串值）{
而（！isA）{
试一试{
等待（）；
}捕获（中断异常例外）{
System.out.println（““+值中的错误”）；
例如printStackTrace（）；
}
}
数组[位置]=值+位置；
System.out.println（数组[位置]）；
位置++；
isA=！isA；
通知（）；
}
公开募捐{
而（getIndex（）你的线程都在等待并通知不同的对象，因此它们根本不相互通信。如果你想让它们有效地相互释放，它们需要一个共享监视器来同步、等待和通知

当您指定一个超时时，它是“工作”的，因为它有效地将等待调用转换为睡眠调用…仍然没有任何东西真正有效地等待/通知，因为这两个线程仍在处理单独的监视器。
您的对象不在同一个监视器中工作

您需要将wait（）和notify（）移动到同一个对象，如：

或者，您可以通知目标对象：

当您设置等待（100）时，您正在设置一个超时。它肯定会在100毫秒后醒来