Java VirtualMachine.TRACE_OBJREFS属性代码示例

List<ThreadReference> allThreads() {
    List<ThreadReference> threads = null;
    try {
        Cache local = getCache();

        if (local != null) {
            // may be stale when returned, but not provably so
            threads = local.threads;
        }
        if (threads == null) {
            threads = Arrays.asList((ThreadReference[])JDWP.VirtualMachine.AllThreads.
                                    process(vm).threads);
            if (local != null) {
                local.threads = threads;
                if ((vm.traceFlags & VirtualMachine.TRACE_OBJREFS) != 0) {
                    vm.printTrace("Caching all threads (count = " +
                                  threads.size() + ") while VM suspended");
                }
            }
        }
    } catch (JDWPException exc) {
        throw exc.toJDIException();
    }
    return threads;
}
 

List<ThreadGroupReference> topLevelThreadGroups() {
    List<ThreadGroupReference> groups = null;
    try {
        Cache local = getCache();

        if (local != null) {
            groups = local.groups;
        }
        if (groups == null) {
            groups = Arrays.asList(
                            (ThreadGroupReference[])JDWP.VirtualMachine.TopLevelThreadGroups.
                                   process(vm).groups);
            if (local != null) {
                local.groups = groups;
                if ((vm.traceFlags & VirtualMachine.TRACE_OBJREFS) != 0) {
                    vm.printTrace(
                      "Caching top level thread groups (count = " +
                      groups.size() + ") while VM suspended");
                }
            }
        }
    } catch (JDWPException exc) {
        throw exc.toJDIException();
    }
    return groups;
}
 

public List<ObjectReference> ownedMonitors()  throws IncompatibleThreadStateException  {
    LocalCache snapshot = localCache;
    try {
        if (snapshot.ownedMonitors == null) {
            snapshot.ownedMonitors = Arrays.asList(
                             (ObjectReference[])JDWP.ThreadReference.OwnedMonitors.
                                     process(vm, this).owned);
            if ((vm.traceFlags & VirtualMachine.TRACE_OBJREFS) != 0) {
                vm.printTrace(description() +
                              " temporarily caching owned monitors"+
                              " (count = " + snapshot.ownedMonitors.size() + ")");
            }
        }
    } catch (JDWPException exc) {
        switch (exc.errorCode()) {
        case JDWP.Error.THREAD_NOT_SUSPENDED:
        case JDWP.Error.INVALID_THREAD:   /* zombie */
            throw new IncompatibleThreadStateException();
        default:
            throw exc.toJDIException();
        }
    }
    return snapshot.ownedMonitors;
}
 

public boolean vmNotSuspended(VMAction action) {
    // make sure that cache and listener management are synchronized
    synchronized (vm.state()) {
        if (cache != null && (vm.traceFlags & VirtualMachine.TRACE_OBJREFS) != 0) {
            vm.printTrace("Clearing temporary cache for " + description());
        }
        disableCache();
        if (addedListener) {
            /*
             * If a listener was added (i.e. this is not a
             * ObjectReference that adds a listener on startup),
             * remove it here.
             */
            addedListener = false;
            return false;  // false says remove
        } else {
            return true;
        }
    }
}
 

public List<ReferenceType> visibleClasses() {
    List<ReferenceType> classes = null;
    try {
        Cache local = (Cache)getCache();

        if (local != null) {
            classes = local.visibleClasses;
        }
        if (classes == null) {
            JDWP.ClassLoaderReference.VisibleClasses.ClassInfo[]
              jdwpClasses = JDWP.ClassLoaderReference.VisibleClasses.
                                        process(vm, this).classes;
            classes = new ArrayList<>(jdwpClasses.length);
            for (int i = 0; i < jdwpClasses.length; ++i) {
                classes.add(vm.referenceType(jdwpClasses[i].typeID,
                                             jdwpClasses[i].refTypeTag));
            }
            classes = Collections.unmodifiableList(classes);
            if (local != null) {
                local.visibleClasses = classes;
                if ((vm.traceFlags & VirtualMachine.TRACE_OBJREFS) != 0) {
                    vm.printTrace(description() +
                       " temporarily caching visible classes (count = " +
                                  classes.size() + ")");
                }
            }
        }
    } catch (JDWPException exc) {
        throw exc.toJDIException();
    }
    return classes;
}
 

/**
 * Tell listeners to invalidate suspend-sensitive caches.
 * If resumingThread != null, then only that thread is being
 * resumed.
 */
synchronized void thaw(ThreadReference resumingThread) {
    if (cache != null) {
        if ((vm.traceFlags & VirtualMachine.TRACE_OBJREFS) != 0) {
            vm.printTrace("Clearing VM suspended cache");
        }
        disableCache();
    }
    processVMAction(new VMAction(vm, resumingThread, VMAction.VM_NOT_SUSPENDED));
}
 

public ObjectReference currentContendedMonitor()
                          throws IncompatibleThreadStateException  {
    LocalCache snapshot = localCache;
    try {
        if (snapshot.contendedMonitor == null &&
            !snapshot.triedCurrentContended) {
            snapshot.contendedMonitor = JDWP.ThreadReference.CurrentContendedMonitor.
                process(vm, this).monitor;
            snapshot.triedCurrentContended = true;
            if ((snapshot.contendedMonitor != null) &&
                ((vm.traceFlags & VirtualMachine.TRACE_OBJREFS) != 0)) {
                vm.printTrace(description() +
                              " temporarily caching contended monitor"+
                              " (id = " + snapshot.contendedMonitor.uniqueID() + ")");
            }
        }
    } catch (JDWPException exc) {
        switch (exc.errorCode()) {
        case JDWP.Error.THREAD_NOT_SUSPENDED:
        case JDWP.Error.INVALID_THREAD:   /* zombie */
            throw new IncompatibleThreadStateException();
        default:
            throw exc.toJDIException();
        }
    }
    return snapshot.contendedMonitor;
}
 

public List<MonitorInfo> ownedMonitorsAndFrames()  throws IncompatibleThreadStateException  {
    LocalCache snapshot = localCache;
    try {
        if (snapshot.ownedMonitorsInfo == null) {
            JDWP.ThreadReference.OwnedMonitorsStackDepthInfo.monitor[] minfo;
            minfo = JDWP.ThreadReference.OwnedMonitorsStackDepthInfo.process(vm, this).owned;

            snapshot.ownedMonitorsInfo = new ArrayList<>(minfo.length);

            for (int i=0; i < minfo.length; i++) {
                MonitorInfo mon = new MonitorInfoImpl(vm, minfo[i].monitor, this, minfo[i].stack_depth);
                snapshot.ownedMonitorsInfo.add(mon);
            }

            if ((vm.traceFlags & VirtualMachine.TRACE_OBJREFS) != 0) {
                vm.printTrace(description() +
                              " temporarily caching owned monitors"+
                              " (count = " + snapshot.ownedMonitorsInfo.size() + ")");
                }
            }

    } catch (JDWPException exc) {
        switch (exc.errorCode()) {
        case JDWP.Error.THREAD_NOT_SUSPENDED:
        case JDWP.Error.INVALID_THREAD:   /* zombie */
            throw new IncompatibleThreadStateException();
        default:
            throw exc.toJDIException();
        }
    }
    return snapshot.ownedMonitorsInfo;
}
 

JDWP.ObjectReference.MonitorInfo jdwpMonitorInfo()
                         throws IncompatibleThreadStateException {
    JDWP.ObjectReference.MonitorInfo info = null;
    try {
        Cache local;

        // getCache() and addlistener() must be synchronized
        // so that no events are lost.
        synchronized (vm.state()) {
            local = getCache();

            if (local != null) {
                info = local.monitorInfo;

                // Check if there will be something to cache
                // and there is not already a listener
                if (info == null && !vm.state().hasListener(this)) {
                    /* For other, less numerous objects, this is done
                     * in the constructor. Since there can be many
                     * ObjectReferences, the VM listener is installed
                     * and removed as needed.
                     * Listener must be installed before process()
                     */
                    vm.state().addListener(this);
                    addedListener = true;
                }
            }
        }
        if (info == null) {
            info = JDWP.ObjectReference.MonitorInfo.process(vm, this);
            if (local != null) {
                local.monitorInfo = info;
                if ((vm.traceFlags & VirtualMachine.TRACE_OBJREFS) != 0) {
                    vm.printTrace("ObjectReference " + uniqueID() +
                                  " temporarily caching monitor info");
                }
            }
        }
    } catch (JDWPException exc) {
         if (exc.errorCode() == JDWP.Error.THREAD_NOT_SUSPENDED) {
             throw new IncompatibleThreadStateException();
         } else {
             throw exc.toJDIException();
         }
     }
    return info;
}