sun.jvm.hotspot.runtime.ObjectMonitor Java Examples

private List getWaitingThreads(ObjectMonitor mon) {
    return vm.saVM().getThreads().getWaitingThreads(mon);
}
 

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()));
        }
    }
}
 

private List getWaitingThreads(ObjectMonitor mon) {
    return vm.saVM().getThreads().getWaitingThreads(mon);
}
 

private List getPendingThreads(ObjectMonitor mon) {
    return vm.saVM().getThreads().getPendingThreads(mon);
}
 

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()));
        }
    }
}
 

private List getWaitingThreads(ObjectMonitor mon) {
    return vm.saVM().getThreads().getWaitingThreads(mon);
}
 

private List getPendingThreads(ObjectMonitor mon) {
    return vm.saVM().getThreads().getPendingThreads(mon);
}
 

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()));
        }
    }
}
 

private List getWaitingThreads(ObjectMonitor mon) {
    return vm.saVM().getThreads().getWaitingThreads(mon);
}
 

private List getPendingThreads(ObjectMonitor mon) {
    return vm.saVM().getThreads().getPendingThreads(mon);
}
 

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()));
        }
    }
}
 

private List getPendingThreads(ObjectMonitor mon) {
    return vm.saVM().getThreads().getPendingThreads(mon);
}
 

private List getPendingThreads(ObjectMonitor mon) {
    return vm.saVM().getThreads().getPendingThreads(mon);
}
 

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()));
        }
    }
}
 

private List getWaitingThreads(ObjectMonitor mon) {
    return vm.saVM().getThreads().getWaitingThreads(mon);
}
 

private List getPendingThreads(ObjectMonitor mon) {
    return vm.saVM().getThreads().getPendingThreads(mon);
}
 

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()));
        }
    }
}
 

private List getWaitingThreads(ObjectMonitor mon) {
    return vm.saVM().getThreads().getWaitingThreads(mon);
}
 

private List getPendingThreads(ObjectMonitor mon) {
    return vm.saVM().getThreads().getPendingThreads(mon);
}
 

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()));
        }
    }
}
 

private List getWaitingThreads(ObjectMonitor mon) {
    return vm.saVM().getThreads().getWaitingThreads(mon);
}