Java Code Examples for sun.jvm.hotspot.oops.Mark#hasMonitor()

The following examples show how to use sun.jvm.hotspot.oops.Mark#hasMonitor() . You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
Source File: ObjectReferenceImpl.java    From TencentKona-8 with GNU General Public License v2.0 4 votes vote down vote up 
private void computeMonitorInfo() {
    monitorInfoCached = true;
    Mark mark = saObject.getMark();
    ObjectMonitor mon = null;
    Address owner = null;
    // check for heavyweight monitor
    if (! mark.hasMonitor()) {
        // check for lightweight monitor
        if (mark.hasLocker()) {
            owner = mark.locker().getAddress(); // save the address of the Lock word
        }
        // implied else: no owner
    } else {
        // this object has a heavyweight monitor
        mon = mark.monitor();

        // The owner field of a heavyweight monitor may be NULL for no
        // owner, a JavaThread * or it may still be the address of the
        // Lock word in a JavaThread's stack. A monitor can be inflated
        // by a non-owning JavaThread, but only the owning JavaThread
        // can change the owner field from the Lock word to the
        // JavaThread * and it may not have done that yet.
        owner = mon.owner();
    }

    // find the owning thread
    if (owner != null) {
        owningThread = vm.threadMirror(owningThreadFromMonitor(owner));
    }

    // compute entryCount
    if (owningThread != null) {
        if (owningThread.getJavaThread().getAddress().equals(owner)) {
            // the owner field is the JavaThread *
            if (Assert.ASSERTS_ENABLED) {
                Assert.that(false, "must have heavyweight monitor with JavaThread * owner");
            }
            entryCount = (int) mark.monitor().recursions() + 1;
        } else {
            // The owner field is the Lock word on the JavaThread's stack
            // so the recursions field is not valid. We have to count the
            // number of recursive monitor entries the hard way.
            entryCount = countLockedObjects(owningThread.getJavaThread(), saObject);
        }
    }

    // find the contenders & waiters
    waitingThreads = new ArrayList();
    if (mon != null) {
        // this object has a heavyweight monitor. threads could
        // be contenders or waiters
        // add all contenders
        List pendingThreads = getPendingThreads(mon);
        // convert the JavaThreads to ThreadReferenceImpls
        for (Iterator itrPend = pendingThreads.iterator(); itrPend.hasNext();) {
            waitingThreads.add(vm.threadMirror((JavaThread) itrPend.next()));
        }

        // add all waiters (threads in Object.wait())
        // note that we don't do this JVMTI way. To do it JVMTI way,
        // we would need to access ObjectWaiter list maintained in
        // ObjectMonitor::_queue. But we don't have this struct exposed
        // in vmStructs. We do waiters list in a way similar to getting
        // pending threads list
        List objWaitingThreads = getWaitingThreads(mon);
        // convert the JavaThreads to ThreadReferenceImpls
        for (Iterator itrWait = objWaitingThreads.iterator(); itrWait.hasNext();) {
            waitingThreads.add(vm.threadMirror((JavaThread) itrWait.next()));
        }
    }
}
Example 2
Source File: ObjectReferenceImpl.java    From jdk8u60 with GNU General Public License v2.0 4 votes vote down vote up 
private void computeMonitorInfo() {
    monitorInfoCached = true;
    Mark mark = saObject.getMark();
    ObjectMonitor mon = null;
    Address owner = null;
    // check for heavyweight monitor
    if (! mark.hasMonitor()) {
        // check for lightweight monitor
        if (mark.hasLocker()) {
            owner = mark.locker().getAddress(); // save the address of the Lock word
        }
        // implied else: no owner
    } else {
        // this object has a heavyweight monitor
        mon = mark.monitor();

        // The owner field of a heavyweight monitor may be NULL for no
        // owner, a JavaThread * or it may still be the address of the
        // Lock word in a JavaThread's stack. A monitor can be inflated
        // by a non-owning JavaThread, but only the owning JavaThread
        // can change the owner field from the Lock word to the
        // JavaThread * and it may not have done that yet.
        owner = mon.owner();
    }

    // find the owning thread
    if (owner != null) {
        owningThread = vm.threadMirror(owningThreadFromMonitor(owner));
    }

    // compute entryCount
    if (owningThread != null) {
        if (owningThread.getJavaThread().getAddress().equals(owner)) {
            // the owner field is the JavaThread *
            if (Assert.ASSERTS_ENABLED) {
                Assert.that(false, "must have heavyweight monitor with JavaThread * owner");
            }
            entryCount = (int) mark.monitor().recursions() + 1;
        } else {
            // The owner field is the Lock word on the JavaThread's stack
            // so the recursions field is not valid. We have to count the
            // number of recursive monitor entries the hard way.
            entryCount = countLockedObjects(owningThread.getJavaThread(), saObject);
        }
    }

    // find the contenders & waiters
    waitingThreads = new ArrayList();
    if (mon != null) {
        // this object has a heavyweight monitor. threads could
        // be contenders or waiters
        // add all contenders
        List pendingThreads = getPendingThreads(mon);
        // convert the JavaThreads to ThreadReferenceImpls
        for (Iterator itrPend = pendingThreads.iterator(); itrPend.hasNext();) {
            waitingThreads.add(vm.threadMirror((JavaThread) itrPend.next()));
        }

        // add all waiters (threads in Object.wait())
        // note that we don't do this JVMTI way. To do it JVMTI way,
        // we would need to access ObjectWaiter list maintained in
        // ObjectMonitor::_queue. But we don't have this struct exposed
        // in vmStructs. We do waiters list in a way similar to getting
        // pending threads list
        List objWaitingThreads = getWaitingThreads(mon);
        // convert the JavaThreads to ThreadReferenceImpls
        for (Iterator itrWait = objWaitingThreads.iterator(); itrWait.hasNext();) {
            waitingThreads.add(vm.threadMirror((JavaThread) itrWait.next()));
        }
    }
}
Example 3
Source File: ObjectReferenceImpl.java    From openjdk-jdk8u with GNU General Public License v2.0 4 votes vote down vote up 
private void computeMonitorInfo() {
    monitorInfoCached = true;
    Mark mark = saObject.getMark();
    ObjectMonitor mon = null;
    Address owner = null;
    // check for heavyweight monitor
    if (! mark.hasMonitor()) {
        // check for lightweight monitor
        if (mark.hasLocker()) {
            owner = mark.locker().getAddress(); // save the address of the Lock word
        }
        // implied else: no owner
    } else {
        // this object has a heavyweight monitor
        mon = mark.monitor();

        // The owner field of a heavyweight monitor may be NULL for no
        // owner, a JavaThread * or it may still be the address of the
        // Lock word in a JavaThread's stack. A monitor can be inflated
        // by a non-owning JavaThread, but only the owning JavaThread
        // can change the owner field from the Lock word to the
        // JavaThread * and it may not have done that yet.
        owner = mon.owner();
    }

    // find the owning thread
    if (owner != null) {
        owningThread = vm.threadMirror(owningThreadFromMonitor(owner));
    }

    // compute entryCount
    if (owningThread != null) {
        if (owningThread.getJavaThread().getAddress().equals(owner)) {
            // the owner field is the JavaThread *
            if (Assert.ASSERTS_ENABLED) {
                Assert.that(false, "must have heavyweight monitor with JavaThread * owner");
            }
            entryCount = (int) mark.monitor().recursions() + 1;
        } else {
            // The owner field is the Lock word on the JavaThread's stack
            // so the recursions field is not valid. We have to count the
            // number of recursive monitor entries the hard way.
            entryCount = countLockedObjects(owningThread.getJavaThread(), saObject);
        }
    }

    // find the contenders & waiters
    waitingThreads = new ArrayList();
    if (mon != null) {
        // this object has a heavyweight monitor. threads could
        // be contenders or waiters
        // add all contenders
        List pendingThreads = getPendingThreads(mon);
        // convert the JavaThreads to ThreadReferenceImpls
        for (Iterator itrPend = pendingThreads.iterator(); itrPend.hasNext();) {
            waitingThreads.add(vm.threadMirror((JavaThread) itrPend.next()));
        }

        // add all waiters (threads in Object.wait())
        // note that we don't do this JVMTI way. To do it JVMTI way,
        // we would need to access ObjectWaiter list maintained in
        // ObjectMonitor::_queue. But we don't have this struct exposed
        // in vmStructs. We do waiters list in a way similar to getting
        // pending threads list
        List objWaitingThreads = getWaitingThreads(mon);
        // convert the JavaThreads to ThreadReferenceImpls
        for (Iterator itrWait = objWaitingThreads.iterator(); itrWait.hasNext();) {
            waitingThreads.add(vm.threadMirror((JavaThread) itrWait.next()));
        }
    }
}
Example 4
Source File: ObjectReferenceImpl.java    From openjdk-jdk8u-backup with GNU General Public License v2.0 4 votes vote down vote up 
private void computeMonitorInfo() {
    monitorInfoCached = true;
    Mark mark = saObject.getMark();
    ObjectMonitor mon = null;
    Address owner = null;
    // check for heavyweight monitor
    if (! mark.hasMonitor()) {
        // check for lightweight monitor
        if (mark.hasLocker()) {
            owner = mark.locker().getAddress(); // save the address of the Lock word
        }
        // implied else: no owner
    } else {
        // this object has a heavyweight monitor
        mon = mark.monitor();

        // The owner field of a heavyweight monitor may be NULL for no
        // owner, a JavaThread * or it may still be the address of the
        // Lock word in a JavaThread's stack. A monitor can be inflated
        // by a non-owning JavaThread, but only the owning JavaThread
        // can change the owner field from the Lock word to the
        // JavaThread * and it may not have done that yet.
        owner = mon.owner();
    }

    // find the owning thread
    if (owner != null) {
        owningThread = vm.threadMirror(owningThreadFromMonitor(owner));
    }

    // compute entryCount
    if (owningThread != null) {
        if (owningThread.getJavaThread().getAddress().equals(owner)) {
            // the owner field is the JavaThread *
            if (Assert.ASSERTS_ENABLED) {
                Assert.that(false, "must have heavyweight monitor with JavaThread * owner");
            }
            entryCount = (int) mark.monitor().recursions() + 1;
        } else {
            // The owner field is the Lock word on the JavaThread's stack
            // so the recursions field is not valid. We have to count the
            // number of recursive monitor entries the hard way.
            entryCount = countLockedObjects(owningThread.getJavaThread(), saObject);
        }
    }

    // find the contenders & waiters
    waitingThreads = new ArrayList();
    if (mon != null) {
        // this object has a heavyweight monitor. threads could
        // be contenders or waiters
        // add all contenders
        List pendingThreads = getPendingThreads(mon);
        // convert the JavaThreads to ThreadReferenceImpls
        for (Iterator itrPend = pendingThreads.iterator(); itrPend.hasNext();) {
            waitingThreads.add(vm.threadMirror((JavaThread) itrPend.next()));
        }

        // add all waiters (threads in Object.wait())
        // note that we don't do this JVMTI way. To do it JVMTI way,
        // we would need to access ObjectWaiter list maintained in
        // ObjectMonitor::_queue. But we don't have this struct exposed
        // in vmStructs. We do waiters list in a way similar to getting
        // pending threads list
        List objWaitingThreads = getWaitingThreads(mon);
        // convert the JavaThreads to ThreadReferenceImpls
        for (Iterator itrWait = objWaitingThreads.iterator(); itrWait.hasNext();) {
            waitingThreads.add(vm.threadMirror((JavaThread) itrWait.next()));
        }
    }
}
Example 5
Source File: ObjectReferenceImpl.java    From hottub with GNU General Public License v2.0 4 votes vote down vote up 
private void computeMonitorInfo() {
    monitorInfoCached = true;
    Mark mark = saObject.getMark();
    ObjectMonitor mon = null;
    Address owner = null;
    // check for heavyweight monitor
    if (! mark.hasMonitor()) {
        // check for lightweight monitor
        if (mark.hasLocker()) {
            owner = mark.locker().getAddress(); // save the address of the Lock word
        }
        // implied else: no owner
    } else {
        // this object has a heavyweight monitor
        mon = mark.monitor();

        // The owner field of a heavyweight monitor may be NULL for no
        // owner, a JavaThread * or it may still be the address of the
        // Lock word in a JavaThread's stack. A monitor can be inflated
        // by a non-owning JavaThread, but only the owning JavaThread
        // can change the owner field from the Lock word to the
        // JavaThread * and it may not have done that yet.
        owner = mon.owner();
    }

    // find the owning thread
    if (owner != null) {
        owningThread = vm.threadMirror(owningThreadFromMonitor(owner));
    }

    // compute entryCount
    if (owningThread != null) {
        if (owningThread.getJavaThread().getAddress().equals(owner)) {
            // the owner field is the JavaThread *
            if (Assert.ASSERTS_ENABLED) {
                Assert.that(false, "must have heavyweight monitor with JavaThread * owner");
            }
            entryCount = (int) mark.monitor().recursions() + 1;
        } else {
            // The owner field is the Lock word on the JavaThread's stack
            // so the recursions field is not valid. We have to count the
            // number of recursive monitor entries the hard way.
            entryCount = countLockedObjects(owningThread.getJavaThread(), saObject);
        }
    }

    // find the contenders & waiters
    waitingThreads = new ArrayList();
    if (mon != null) {
        // this object has a heavyweight monitor. threads could
        // be contenders or waiters
        // add all contenders
        List pendingThreads = getPendingThreads(mon);
        // convert the JavaThreads to ThreadReferenceImpls
        for (Iterator itrPend = pendingThreads.iterator(); itrPend.hasNext();) {
            waitingThreads.add(vm.threadMirror((JavaThread) itrPend.next()));
        }

        // add all waiters (threads in Object.wait())
        // note that we don't do this JVMTI way. To do it JVMTI way,
        // we would need to access ObjectWaiter list maintained in
        // ObjectMonitor::_queue. But we don't have this struct exposed
        // in vmStructs. We do waiters list in a way similar to getting
        // pending threads list
        List objWaitingThreads = getWaitingThreads(mon);
        // convert the JavaThreads to ThreadReferenceImpls
        for (Iterator itrWait = objWaitingThreads.iterator(); itrWait.hasNext();) {
            waitingThreads.add(vm.threadMirror((JavaThread) itrWait.next()));
        }
    }
}
Example 6
Source File: ObjectReferenceImpl.java    From openjdk-8-source with GNU General Public License v2.0 4 votes vote down vote up 
private void computeMonitorInfo() {
    monitorInfoCached = true;
    Mark mark = saObject.getMark();
    ObjectMonitor mon = null;
    Address owner = null;
    // check for heavyweight monitor
    if (! mark.hasMonitor()) {
        // check for lightweight monitor
        if (mark.hasLocker()) {
            owner = mark.locker().getAddress(); // save the address of the Lock word
        }
        // implied else: no owner
    } else {
        // this object has a heavyweight monitor
        mon = mark.monitor();

        // The owner field of a heavyweight monitor may be NULL for no
        // owner, a JavaThread * or it may still be the address of the
        // Lock word in a JavaThread's stack. A monitor can be inflated
        // by a non-owning JavaThread, but only the owning JavaThread
        // can change the owner field from the Lock word to the
        // JavaThread * and it may not have done that yet.
        owner = mon.owner();
    }

    // find the owning thread
    if (owner != null) {
        owningThread = vm.threadMirror(owningThreadFromMonitor(owner));
    }

    // compute entryCount
    if (owningThread != null) {
        if (owningThread.getJavaThread().getAddress().equals(owner)) {
            // the owner field is the JavaThread *
            if (Assert.ASSERTS_ENABLED) {
                Assert.that(false, "must have heavyweight monitor with JavaThread * owner");
            }
            entryCount = (int) mark.monitor().recursions() + 1;
        } else {
            // The owner field is the Lock word on the JavaThread's stack
            // so the recursions field is not valid. We have to count the
            // number of recursive monitor entries the hard way.
            entryCount = countLockedObjects(owningThread.getJavaThread(), saObject);
        }
    }

    // find the contenders & waiters
    waitingThreads = new ArrayList();
    if (mon != null) {
        // this object has a heavyweight monitor. threads could
        // be contenders or waiters
        // add all contenders
        List pendingThreads = getPendingThreads(mon);
        // convert the JavaThreads to ThreadReferenceImpls
        for (Iterator itrPend = pendingThreads.iterator(); itrPend.hasNext();) {
            waitingThreads.add(vm.threadMirror((JavaThread) itrPend.next()));
        }

        // add all waiters (threads in Object.wait())
        // note that we don't do this JVMTI way. To do it JVMTI way,
        // we would need to access ObjectWaiter list maintained in
        // ObjectMonitor::_queue. But we don't have this struct exposed
        // in vmStructs. We do waiters list in a way similar to getting
        // pending threads list
        List objWaitingThreads = getWaitingThreads(mon);
        // convert the JavaThreads to ThreadReferenceImpls
        for (Iterator itrWait = objWaitingThreads.iterator(); itrWait.hasNext();) {
            waitingThreads.add(vm.threadMirror((JavaThread) itrWait.next()));
        }
    }
}
Example 7
Source File: ObjectReferenceImpl.java    From openjdk-8 with GNU General Public License v2.0 4 votes vote down vote up 
private void computeMonitorInfo() {
    monitorInfoCached = true;
    Mark mark = saObject.getMark();
    ObjectMonitor mon = null;
    Address owner = null;
    // check for heavyweight monitor
    if (! mark.hasMonitor()) {
        // check for lightweight monitor
        if (mark.hasLocker()) {
            owner = mark.locker().getAddress(); // save the address of the Lock word
        }
        // implied else: no owner
    } else {
        // this object has a heavyweight monitor
        mon = mark.monitor();

        // The owner field of a heavyweight monitor may be NULL for no
        // owner, a JavaThread * or it may still be the address of the
        // Lock word in a JavaThread's stack. A monitor can be inflated
        // by a non-owning JavaThread, but only the owning JavaThread
        // can change the owner field from the Lock word to the
        // JavaThread * and it may not have done that yet.
        owner = mon.owner();
    }

    // find the owning thread
    if (owner != null) {
        owningThread = vm.threadMirror(owningThreadFromMonitor(owner));
    }

    // compute entryCount
    if (owningThread != null) {
        if (owningThread.getJavaThread().getAddress().equals(owner)) {
            // the owner field is the JavaThread *
            if (Assert.ASSERTS_ENABLED) {
                Assert.that(false, "must have heavyweight monitor with JavaThread * owner");
            }
            entryCount = (int) mark.monitor().recursions() + 1;
        } else {
            // The owner field is the Lock word on the JavaThread's stack
            // so the recursions field is not valid. We have to count the
            // number of recursive monitor entries the hard way.
            entryCount = countLockedObjects(owningThread.getJavaThread(), saObject);
        }
    }

    // find the contenders & waiters
    waitingThreads = new ArrayList();
    if (mon != null) {
        // this object has a heavyweight monitor. threads could
        // be contenders or waiters
        // add all contenders
        List pendingThreads = getPendingThreads(mon);
        // convert the JavaThreads to ThreadReferenceImpls
        for (Iterator itrPend = pendingThreads.iterator(); itrPend.hasNext();) {
            waitingThreads.add(vm.threadMirror((JavaThread) itrPend.next()));
        }

        // add all waiters (threads in Object.wait())
        // note that we don't do this JVMTI way. To do it JVMTI way,
        // we would need to access ObjectWaiter list maintained in
        // ObjectMonitor::_queue. But we don't have this struct exposed
        // in vmStructs. We do waiters list in a way similar to getting
        // pending threads list
        List objWaitingThreads = getWaitingThreads(mon);
        // convert the JavaThreads to ThreadReferenceImpls
        for (Iterator itrWait = objWaitingThreads.iterator(); itrWait.hasNext();) {
            waitingThreads.add(vm.threadMirror((JavaThread) itrWait.next()));
        }
    }
}