Java 线程在wait（）之后唤醒并再次获取监视器，是从wait（）之后的下一条指令继续，还是从开始继续？

假设一个

线程执行以下操作：

synchronized(o) {
    dosomthing1;
    o.wait();
    dosomthing2;
}

假设线程_1被唤醒，在获取
o
monitor时被阻塞，获取它。下一个
线程\u 1
指令是什么
dosomthing1
或
dosomthing2
？
让我们假设我们有两种方法
printFirst（）
将从0打印到5，
printsond（）
将从0打印到10

void printFirst() {
    for (int i = 0; i <= 5; i++) {
        System.out.print(i + " ");
    }
}

void printSecond() {
    for (int i = 0; i <= 10; i++) {
        System.out.print(i + " ");
    }
}


另一个方法将从Thread-1执行，它将打印一些内容，并将
通知处于当前
等待
状态的线程

synchronized void testThreadNotify(){
    System.out.println("\n" + Thread.currentThread().getName() + "starting to work");
    System.out.println("Thread one is waiting");
    System.out.println("Preparing to notify Thread One");
    notify();
}

调用wait（）方法时，
Thread-0
将继续执行其工作，在这种情况下，将调用wait（）方法下方的方法
printSecond（）
，并打印0-10之间的数字

完整代码

class TestThread{

    void printFirst() {
        for (int i = 0; i <= 5; i++) {
            System.out.print(i + " ");
        }
    }

    void printSecond() {
        for (int i = 0; i <= 10; i++) {
            System.out.print(i + " ");
        }
    }

    synchronized void testThreadWait(){
        System.out.println(Thread.currentThread().getName() +" starting to work");
        try {
            printFirst();
            wait();
            System.out.println(Thread.currentThread().getName() + "starts");
            printSecond();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("This will be printed after wait");
    }

    synchronized void testThreadNotify(){
        System.out.println(Thread.currentThread().getName() + "starting to work");
        System.out.println("Thread one is waiting");
        System.out.println("Preparing to notify Thread One");
        notify();
    }
}

public class Test{
    public static void main(String args[]){
        final TestThread c=new TestThread();
        new Thread(){
            public void run(){c.testThreadWait();}
        }.start();
        new Thread(){
            public void run(){c.testThreadNotify();}
        }.start();
    }
}

类TestThread{
void printFirst（）{
对于（int i=0；i
dosomething2
。你可以编写简单的程序来验证这一点，为什么要问？因为我编写的程序可能包含bug，但我想100%了解这一点right@J.J.Beam创建小型、自包含且简单的程序来测试这种行为是学习和开发的一项重要技能用另一个线程在延迟后通知对象，rintln（“1”）；o.wait（）；System.out.println（“2”）
将为您提供所需的答案，而不会过于复杂，以至于无法确定您的程序是否包含“可能的bug”.因为我不知道这么简单的java东西，我的小程序可能包含bug，但我想学习正确的东西。你认为这是为什么？
class TestThread{

    void printFirst() {
        for (int i = 0; i <= 5; i++) {
            System.out.print(i + " ");
        }
    }

    void printSecond() {
        for (int i = 0; i <= 10; i++) {
            System.out.print(i + " ");
        }
    }

    synchronized void testThreadWait(){
        System.out.println(Thread.currentThread().getName() +" starting to work");
        try {
            printFirst();
            wait();
            System.out.println(Thread.currentThread().getName() + "starts");
            printSecond();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("This will be printed after wait");
    }

    synchronized void testThreadNotify(){
        System.out.println(Thread.currentThread().getName() + "starting to work");
        System.out.println("Thread one is waiting");
        System.out.println("Preparing to notify Thread One");
        notify();
    }
}

public class Test{
    public static void main(String args[]){
        final TestThread c=new TestThread();
        new Thread(){
            public void run(){c.testThreadWait();}
        }.start();
        new Thread(){
            public void run(){c.testThreadNotify();}
        }.start();
    }
}

Thread-0 starting to work
0 1 2 3 4 5 
Thread-1starting to work
Thread one is waiting
Preparing to notify Thread One
Thread-0starts
0 1 2 3 4 5 6 7 8 9 10 <--- prints only printSecond()