多线程问题，Object.wait() 和 Object.notify() 如何理解？

Question

看书上的意思是：
wait()， 线程会释放占有的对象锁，然后线程进入休眠状态， 直到有其他线程调用notify！
notify(), 唤醒对象锁操作。可是问题来了：public class MyThreadPrinter2 implements Runnable {     
    
    private String name;     
    private Object prev;     
    private Object self;     
    
    private MyThreadPrinter2(String name, Object prev, Object self) {     
        this.name = name;     
        this.prev = prev;     
        this.self = self;     
    }     
    
    @Override    
    public void run() {     
        int count = 10;     
        while (count > 0) {     
            synchronized (prev) {     
                synchronized (self) {     
                    System.out.print(name+"\n");     
                    count--;    
                    self.notify();//？？？怎么变成了释放锁啦？释放锁应该是wait  self.notify()释放自身对象锁，唤醒下一个等待线程！
                }     
                try {     
                    prev.wait();//释放prev对象锁， 终止当前线程， 等待循环结束后再次被唤醒。      
                } catch (InterruptedException e) {     
                    e.printStackTrace();     
                }     
            }     
    
        }     
    }     
    
    public static void main(String[] args) throws Exception {     
        Object a = new Object();     
        Object b = new Object();     
        Object c = new Object();     
        MyThreadPrinter2 pa = new MyThreadPrinter2("A", c, a);     
        MyThreadPrinter2 pb = new MyThreadPrinter2("B", a, b);     
        MyThreadPrinter2 pc = new MyThreadPrinter2("C", b, c);     
             
             
        new Thread(pa).start();  
       
        new Thread(pb).start(); 
        
        new Thread(pc).start(); 
        System.out.println("in main!");
        }    
    self.notify();？？？怎么变成了释放锁啦？释放锁应该是wait  self.notify()释放自身对象锁，唤醒下一个等待线程！
我的理解应该是self.wait()才对！

Answer 1

不太理解你说的什么wait()/notify()是释放锁.这两个方法,一个是让当前线程等待,另一个是通知针对某个对象等待的线程启动.
如果硬要说锁的问题的话那么实际上是在同步代码块或者同步方法一开始就是加锁,然后当退出同步代码块或者是同步方法的时候释放锁.而不关wait()或者notify()事情.
再或者锁应该就是java.util.concurrent.locks.Lock;接口做的锁.
如果还是不理解的话可以举些例子给你看.

Answer 2

当然可能你想说的意思可能是只当调用wait()的时候本线程等待,交出权限给其他的线程的意思？

Answer 3

你可以理解下下面的代码public class Test{
public static void main(String[] args){
Object o = new Object();
Task1 task1 = new Task1(o);
Task2 task2 = new Task2(o); Thread thread1 = new Thread(task1);
Thread thread2 = new Thread(task2); thread1.start(); try{
Thread.sleep(1000);
}catch(InterruptedException e){
e.printStackTrace();
} thread2.start();
}
}class Task1 implements Runnable{
public Task1(Object o){
this.o = o;
} @Override
public void run(){
synchronized(o){
try{
System.out.printf("%s:(1)这个线程先启动.但是到达wait()的时候本线程会停止并交出对象的占有权\n",Thread.currentThread().getName());
o.wait();//将控制权交给其他对o对象进行同步的线程.
System.out.printf("%s:(5)当其他的线程调用对象的notify/notifyAll方法的时候会结束本线程的等待状态.\n",Thread.currentThread().getName());
}catch(InterruptedException e){
e.printStackTrace();
}
}
} private Object o;
}class Task2 implements Runnable{
public Task2(Object o){
this.o = o;
} @Override
public void run(){
synchronized(o){
try{
System.out.printf("%s:(2)线程启动,并且等待1秒钟后调用对象的notifyAll().\n",Thread.currentThread().getName());
Thread.sleep(1000);
o.notifyAll();
System.out.printf("%s:(3)这里已经调用了对象的notifyAll()方法,但是由于仍然处于同步代码块中,所以需要继续执行本线程.\n",Thread.currentThread().getName());
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.printf("%s:(4)这里会继续先执行,执行完后再执行其他对应对象的同步线程.\n",Thread.currentThread().getName());
}//锁自动释放
}
private Object o;
}