Java多线程中wait()和notify()

最新推荐文章于 2025-01-20 22:17:35 发布

原创最新推荐文章于 2025-01-20 22:17:35 发布 · 589 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#多线程 #wait #notify

多线程专栏收录该内容

0 篇文章

订阅专栏

本文通过实例详细介绍了Java中wait()和notify()方法的工作原理及其应用。通过三个线程的交互，实现按顺序打印字符的功能，展示了如何利用这些方法解决线程间的同步问题。

wait()：线程在获取对象锁之后，主动释放对象锁，同时，让本线程休眠。直到有其它线程调用对象的notify()唤醒该线程，才能继续获取对象锁，并继续执行。
notify()：对对象锁的唤醒操作。

注意：
1、Obj.wait()和Obj.notify()必须要与synchronized(Obj)一起使用，也就是wait,与notify是针对已经获取了Obj锁进行操作，从语法角度来说就是Obj.wait(),Obj.notify必须在synchronized(Obj){…}语句块内。
2、notify()调用后，并不是马上就释放当前线程的对象锁而唤醒相应线程的对象锁，而是在相应的synchronized(){}语句块执行结束，自动释放锁后，JVM会在wait()对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。这样就提供了在线程间同步、唤醒的操作。
3、Thread.sleep()与Object.wait()二者都可以暂停当前线程，释放CPU控制权，主要的区别在于Object.wait()在释放CPU同时，释放了对象锁的控制。

下面看一个例子：
建立三个线程，A线程打印10个”A”，B线程打印10个”B”，C线程打印10个”C”，要求线程同时运行，交替打印10次ABC。这个问题用Object的wait()，notify()就可以很方便的解决。代码如下：

public class ThreadTest2 {
    public static void main(String[] args) throws InterruptedException {
        Object a=new Object();
        Object b=new Object();
        Object c=new Object();
        Thread ta=new Thread(new ThreadPrint("A",c,a));
        Thread tb=new Thread(new ThreadPrint("B",a,b));
        Thread tc=new Thread(new ThreadPrint("C",b,c));

        ta.start();
        Thread.sleep(100);
        tb.start();
        Thread.sleep(100);
        tc.start();
        Thread.sleep(100);
    }
}

class ThreadPrint implements Runnable{
    private String name;
    //前一个对象锁
    private Object prev;
    //当前对象锁
    private Object self;

    public ThreadPrint(String name, Object prev, Object self){
        this.name=name;
        this.prev=prev;
        this.self=self;
    }
    public void run() {
        int count=10;
        while(count>0){
            synchronized(prev) {
                synchronized(self) {
                    System.out.print(name);
                    count--;
                    //唤醒当前对象锁
                    self.notify();
                }
                try {
                    //释放前一个对象锁
                    prev.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

输出结果：ABCABCABCABCABCABCABCABCABCABC

先来解释一下其整体思路，从大的方向上来讲，该问题为三线程间的同步唤醒操作，主要的目的就是ThreadA->ThreadB->ThreadC->ThreadA……循环执行三个线程。为了控制线程执行的顺序，那么就必须要确定唤醒、等待的顺序，所以每一个线程必须同时持有两个对象锁，才能继续执行。一个对象锁是prev，就是前一个线程所持有的对象锁。还有一个就是自身对象锁。主要的思想就是，为了控制执行的顺序，必须要先持有prev锁，也就前一个线程要释放自身对象锁，再去申请自身对象锁，两者兼备时打印，之后首先调用self.notify()释放自身对象锁，唤醒下一个等待线程，再调用prev.wait()释放prev对象锁，终止当前线程，等待循环结束后再次被唤醒。运行上述代码，可以发现三个线程循环打印ABC，共10次。程序运行的主要过程就是A线程最先运行，持有C,A对象锁，后释放A,C锁，唤醒B。线程B等待A锁，再申请B锁，后打印B，再释放B，A锁，唤醒C，线程C等待B锁，再申请C锁，后打印C，再释放C,B锁，唤醒A。看起来似乎没什么问题，但如果你仔细想一下，就会发现有问题，就是初始条件，三个线程按照A,B,C的顺序来启动，按照前面的思考，A唤醒B，B唤醒C，C再唤醒A。但是这种假设依赖于JVM中线程调度、执行的顺序。