java的Object里wait()实现原理讲解

编辑: admin 分类: java 发布时间: 2021-12-04 来源:互联网

Object中的wait()实现原理

在进行wait()之前，就代表着需要争夺Synchorized，而Synchronized代码块通过javap生成的字节码中包含monitorenter和monitorexit两个指令。

当在进加锁的时候会执行monitorenter指令，执行该指令可以获取对象的monitor。同时在执行Lock.wait()的时候也必须持有monitor对象。

在多核环境下，多个线程有可能同时执行monitorenter指令，并获取lock对象关联的monitor，但只有一个线程可以和monitor建立关联，这个线程执行到wait方法时，wait方法会将当前线程放入wait set，使其进行等待直到被唤醒，并放弃lock对象上的所有同步声明，意味着该线程释放了锁，其他线程可以重新执行加锁操作，notify方法会选择wait set中任意一个线程进行唤醒，notifyAll方法会唤醒monitor的wait set中所有线程。执行完notify方法并不会立马唤醒等待线程。那么wait具体是怎么实现的呢？

首先在HotSpot虚拟机中，monitor采用ObjectMonitor实现，每个线程都具有两个队列，分别为free和used，用来存放ObjectMonitor。如果当前free列表为空，线程将向全局global list请求分配ObjectMonitor。

ObjectMonitor对象中有两个队列，都用来保存ObjectWaiter对象，分别是_WaitSet 和 _EntrySet。_owner用来指向获得ObjectMonitor对象的线程

ObjectWaiter对象是双向链表结构，保存了_thread（当前线程）以及当前的状态TState等数据，每个等待锁的线程都会被封装成ObjectWaiter对象。

_WaitSet：处于wait状态的线程，会被加入到wait set；
_EntrySett：处于等待锁block状态的线程，会被加入到entry set；

wait方法实现

lock.wait()方法最终通过ObjectMonitor的 wait(jlong millis, bool interruptable, TRAPS)实现

1、将当前线程封装成ObjectWaiter对象node

2、通过ObjectMonitor::AddWaiter方法将node添加到_WaitSet列表中

3、通过ObjectMonitor::exit方法释放当前的ObjectMonitor对象，这样其它竞争线程就可以获取该ObjectMonitor对象

4、最终底层的park方法会挂起线程

ObjectSynchorizer::wait方法通过Object对象找到ObjectMonitor对象来调用方法 ObjectMonitor::wait()，通过调用ObjectMonitor::AddWaiter()可以把新建的ObjectWaiter对象，放入到_WaitSet队列的末尾，然后在ObjectMonitor::exit释放锁，接着通过执行thread_ParkEvent->park来挂起线程，也就是进行wait。

Object对象中的wait,notify,notifyAll的理解

wait，notify，notifyAll 是定义在Object类的实例方法，用于控制线程状态，在线程协作时，大家都会用到notify()或者notifyAll()方法，其中wait与notify是java同步机制中重要的组成部分，需要结合与synchronized关键字才能使用，在调用一个Object的wait与notify/notifyAll的时候，必须保证调用代码对该Object是同步的，也就是说必须在作用等同于synchronized(object){......}的内部才能够去调用obj的wait与notify/notifyAll三个方法，否则就会报错：java.lang.IllegalMonitorStateException:current thread not owner(意思是因为没有同步，所以线程对对象锁的状态是不确定的，不能调用这些方法)。

wait的目的就在于暴露出对象锁，所以需要保证在lock的同步代码中调用lock.wait()方法，让其他线程可以通过对象的notify叫醒等待在该对象的等该池里的线程。同样notify也会释放对象锁，在调用之前必须获得对象的锁，不然也会报异常。所以，在线程自动释放其占有的对象锁后，不会去申请对象锁，只有当线程被唤醒的时候或者达到最大的睡眠时间，它才再次争取对象锁的权利

主要方法：

(1).wait()

等待对象的同步锁,需要获得该对象的同步锁才可以调用这个方法,否则编译可以通过，但运行时会收到一个异常：IllegalMonitorStateException。调用任意对象的 wait() 方法导致该线程阻塞，该线程不可继续执行，并且该对象上的锁被释放。

(2).notify()

唤醒在等待该对象同步锁的线程(只唤醒一个,如果有多个在等待),注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。调用任意对象的notify()方法则导致因调用该对象的 wait()方法而阻塞的线程中随机选择的一个解除阻塞（但要等到获得锁后才真正可执行）。

(3).notifyAll()

唤醒所有等待的线程,注意唤醒的是notify之前wait的线程,对于notify之后的wait线程是没有效果的。

通过一个实例来看一下实际的效果，开启两个线和，一个线程打印1到52的数字，一个打印A到Z的字母，要求，打印两个数，打印一个字母，这样交替顺序打印，代码如下：

/**
 * create by spy on 2018/6/4
 */
public class ShuZiZiMuThread {
    public static void main(String[] args) {
        Object object = new Object();
        shuzi shuzi = new shuzi(object);
        zimu zimu = new zimu(object);
        Thread t = new Thread(shuzi);
        t.setName("shuzi");
        Thread t1 = new Thread(zimu);
        t1.setName("zimu");
        t.start();//数字线程先运行
        t1.start();
    }
}
class shuzi implements Runnable{
    private Object object;
    //声明类的引用
    public shuzi(Object object) {
        this.object = object;
    }
    public void run() {
        synchronized (object) {//上锁
            for(int i=1;i<53;i++){
                System.out.print(i+",");
                if(i%2==0){
                    object.notifyAll();//唤醒其它争夺权限的线程
                    try {
                        object.wait();//释放锁，进入等待
                        System.out.println("数字打印类打全打印当前对象拥有对象锁的线程"+Thread.currentThread().getName());//输出当前拥有锁的线程名称
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}
class zimu implements Runnable{
    private Object object;
    public zimu(Object object) {
        this.object = object;
    }
    public void run() {
        synchronized (object) {
            for(int j=65;j<91;j++){
                char c = (char)j;
                System.out.print(c);
                object.notifyAll();//唤醒其它争夺权限的线程
                try {
                    object.wait();//释放锁，进入等待
                    System.out.println("字母打印类打全打印当前对象拥有对象锁的线程"+Thread.currentThread().getName());//输出当前拥有锁的线程名称
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

实际运行的结果：

1,2,A数字打印类打印当前对象拥有对象锁的线程shuzi
3,4,字母打印类打印当前对象拥有对象锁的线程zimu
B数字打印类打印当前对象拥有对象锁的线程shuzi
5,6,字母打印类打印当前对象拥有对象锁的线程zimu
C数字打印类打印当前对象拥有对象锁的线程shuzi
7,8,字母打印类打印当前对象拥有对象锁的线程zimu
D数字打印类打印当前对象拥有对象锁的线程shuzi
9,10,字母打印类打印当前对象拥有对象锁的线程zimu
E数字打印类打印当前对象拥有对象锁的线程shuzi
11,12,字母打印类打印当前对象拥有对象锁的线程zimu
F数字打印类打印当前对象拥有对象锁的线程shuzi
13,14,字母打印类打印当前对象拥有对象锁的线程zimu
G数字打印类打印当前对象拥有对象锁的线程shuzi
15,16,字母打印类打印当前对象拥有对象锁的线程zimu
H数字打印类打印当前对象拥有对象锁的线程shuzi
17,18,字母打印类打印当前对象拥有对象锁的线程zimu
I数字打印类打印当前对象拥有对象锁的线程shuzi
19,20,字母打印类打印当前对象拥有对象锁的线程zimu
J数字打印类打印当前对象拥有对象锁的线程shuzi
21,22,字母打印类打印当前对象拥有对象锁的线程zimu
K数字打印类打印当前对象拥有对象锁的线程shuzi
23,24,字母打印类打印当前对象拥有对象锁的线程zimu
L数字打印类打印当前对象拥有对象锁的线程shuzi
25,26,字母打印类打印当前对象拥有对象锁的线程zimu
M数字打印类打印当前对象拥有对象锁的线程shuzi
27,28,字母打印类打印当前对象拥有对象锁的线程zimu
N数字打印类打印当前对象拥有对象锁的线程shuzi
29,30,字母打印类打印当前对象拥有对象锁的线程zimu
O数字打印类打印当前对象拥有对象锁的线程shuzi
31,32,字母打印类打印当前对象拥有对象锁的线程zimu
P数字打印类打印当前对象拥有对象锁的线程shuzi
33,34,字母打印类打印当前对象拥有对象锁的线程zimu
Q数字打印类打印当前对象拥有对象锁的线程shuzi
35,36,字母打印类打印当前对象拥有对象锁的线程zimu
R数字打印类打印当前对象拥有对象锁的线程shuzi
37,38,字母打印类打印当前对象拥有对象锁的线程zimu
S数字打印类打印当前对象拥有对象锁的线程shuzi
39,40,字母打印类打印当前对象拥有对象锁的线程zimu
T数字打印类打印当前对象拥有对象锁的线程shuzi
41,42,字母打印类打印当前对象拥有对象锁的线程zimu
U数字打印类打印当前对象拥有对象锁的线程shuzi
43,44,字母打印类打印当前对象拥有对象锁的线程zimu
V数字打印类打印当前对象拥有对象锁的线程shuzi
45,46,字母打印类打印当前对象拥有对象锁的线程zimu
W数字打印类打印当前对象拥有对象锁的线程shuzi
47,48,字母打印类打印当前对象拥有对象锁的线程zimu
X数字打印类打印当前对象拥有对象锁的线程shuzi
49,50,字母打印类打印当前对象拥有对象锁的线程zimu
Y数字打印类打印当前对象拥有对象锁的线程shuzi
51,52,字母打印类打印当前对象拥有对象锁的线程zimu
Z数字打印类打印当前对象拥有对象锁的线程shuzi

结果分析：

通过结果可以看出：

在字母打一打印类里调用完

object.notifyAll();//唤醒其它争夺权限的线程
object.wait();//释放锁，进入等待后，拥有对象锁的线程是shuzi在数字打印类里 调用完
object.notifyAll();//唤醒其它争夺权限的线程
object.wait();//释放锁，进入等待后，拥有对象锁的线程是zimu

以上为个人经验，希望能给大家一个参考，也希望大家多多支持自由互联。

【出处：美国高防服务器网络转载请说明出处】

海外服务器