Examples of java.lang.management.ThreadInfo

java.lang.management.ThreadInfo
Thread information. ThreadInfo contains the information about a thread including:
General thread information
- Thread ID.
- Name of the thread.
Execution information
- Thread state.
- The object upon which the thread is blocked due to:
  - waiting to enter a synchronization block/method, or
  - waiting to be notified in a {@link Object#wait Object.wait} method,or
  - parking due to a {@link java.util.concurrent.locks.LockSupport#park LockSupport.park} call.
- The ID of the thread that owns the object that the thread is blocked.
- Stack trace of the thread.
- List of object monitors locked by the thread.
- List of ownable synchronizers locked by the thread.
Synchronization Statistics
- The number of times that the thread has blocked for synchronization or waited for notification.
- The accumulated elapsed time that the thread has blocked for synchronization or waited for notification since {@link ThreadMXBean#setThreadContentionMonitoringEnabled thread contention monitoring}was enabled. Some Java virtual machine implementation may not support this. The {@link ThreadMXBean#isThreadContentionMonitoringSupported()}method can be used to determine if a Java virtual machine supports this.
This thread information class is designed for use in monitoring of the system, not for synchronization control.
MXBean Mapping
ThreadInfo is mapped to a {@link CompositeData CompositeData}with attributes as specified in the {@link #from from} method. @see ThreadMXBean#getThreadInfo @see ThreadMXBean#dumpAllThreads @author Mandy Chung @version 1.25, 05/05/06 @since 1.5

  /**
   * @return true if the given thread ID appears to be a Jetty selector thread
   * based on its stack trace
   */
  private static boolean isJettySelectorThread(long tid) {
    ThreadInfo info = threadBean.getThreadInfo(tid, 20);
    for (StackTraceElement stack : info.getStackTrace()) {
      // compare class names instead of classses, since
      // jetty uses a different classloader
      if (SelectChannelConnector.class.getName().equals(
          stack.getClassName())) {
        LOG.debug("Thread #" + tid + " (" + info.getThreadName() + ") " +
            "is a Jetty selector thread.");
        return true;
      }
    }
    LOG.debug("Thread #" + tid + " (" + info.getThreadName() + ") " +
      "is not a jetty thread");
    return false;
  }

View Full Code Here

    boolean contention = threadBean.isThreadContentionMonitoringEnabled();
    long[] threadIds = threadBean.getAllThreadIds();
    stream.println("Process Thread Dump: " + title);
    stream.println(threadIds.length + " active threads");
    for (long tid: threadIds) {
      ThreadInfo info = threadBean.getThreadInfo(tid, STACK_DEPTH);
      if (info == null) {
        stream.println("  Inactive");
        continue;
      }
      stream.println("Thread " + 
                     getTaskName(info.getThreadId(),
                                 info.getThreadName()) + ":");
      Thread.State state = info.getThreadState();
      stream.println("  State: " + state);
      stream.println("  Blocked count: " + info.getBlockedCount());
      stream.println("  Waited count: " + info.getWaitedCount());
      if (contention) {
        stream.println("  Blocked time: " + info.getBlockedTime());
        stream.println("  Waited time: " + info.getWaitedTime());
      }
      if (state == Thread.State.WAITING) {
        stream.println("  Waiting on " + info.getLockName());
      } else  if (state == Thread.State.BLOCKED) {
        stream.println("  Blocked on " + info.getLockName());
        stream.println("  Blocked by " + 
                       getTaskName(info.getLockOwnerId(),
                                   info.getLockOwnerName()));
      }
      stream.println("  Stack:");
      for (StackTraceElement frame: info.getStackTrace()) {
        stream.println("    " + frame.toString());
      }
    }
    stream.flush();
  }

View Full Code Here

            }
            stackTrace = newStackTrace;
        }


        // Ask our native to instantiate a ThreadInfo for us
        ThreadInfo ti = createThreadInfoImpl(threadId, threadName, threadState,
                isSuspendedImpl(thread), isInNative,
                getThreadBlockedCountImpl(thread), blockedTime,
                getThreadWaitedCountImpl(thread), waitedTime, lockName,
                lockOwnerId, lockOwnerName, stackTrace);
        return ti;

View Full Code Here

        long threadId = record.getThreadID();
        String threadName = "" + record.getThreadID();
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
        for (long id : threadMXBean.getAllThreadIds()) {
            if (id == threadId) {
                ThreadInfo threadInfo = threadMXBean.getThreadInfo(id);
                if (threadInfo != null) {
                    threadName = threadInfo.getThreadName();
                }
                break;
            }
        }

View Full Code Here

    ThreadUsage threadUsage = new ThreadUsage();
    long [] threadIds = threadMxBean.getAllThreadIds();
    threadUsage.liveThreadCount = threadIds.length;
    
    for(long tId : threadIds) {
      ThreadInfo threadInfo = threadMxBean.getThreadInfo(tId);
      threadUsage.threadData.put(new Long(tId).toString(), new ThreadData(threadInfo.getThreadName(), threadInfo.getThreadState().name(),
                                        threadMxBean.getThreadCpuTime(tId)));
      
    }
    return threadUsage;
  }

View Full Code Here

            {
                base.evaluate();
                final long endTime = clock.time();


                final long threadId = Thread.currentThread().getId();
                final ThreadInfo threadInfo = threadMXBean.getThreadInfo(threadId);
                final long threadBlockedTime = threadInfo.getBlockedTime();
                final long roundBlockedTime = threadBlockedTimes.containsKey(threadId)
                        ? threadBlockedTime - threadBlockedTimes.get(threadId)
                        : threadBlockedTime;
                threadBlockedTimes.put(threadId,threadBlockedTime);

View Full Code Here

        StringBuilder sb=new StringBuilder();
        ThreadMXBean bean=ManagementFactory.getThreadMXBean();
        long[] ids=bean.getAllThreadIds();
        ThreadInfo[] threads=bean.getThreadInfo(ids, 20);
        for(int i=0; i < threads.length; i++) {
            ThreadInfo info=threads[i];
            if(info == null)
                continue;
            sb.append(info.getThreadName()).append(":\n");
            StackTraceElement[] stack_trace=info.getStackTrace();
            for(int j=0; j < stack_trace.length; j++) {
                StackTraceElement el=stack_trace[j];
                sb.append("at ").append(el.getClassName()).append(".").append(el.getMethodName());
                sb.append("(").append(el.getFileName()).append(":").append(el.getLineNumber()).append(")");
                sb.append("\n");

View Full Code Here

        }
        Thread.sleep(cpuMonitorTime);
        ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);
        List<JThreadInfo> jThreadInfos = new ArrayList<JThreadInfo>(threadInfos.length);
        for (int i = 0; i < threadInfos.length; i++) {
            ThreadInfo threadInfo = threadInfos[i];
            long threadId = threadInfo.getThreadId();
            long cpuTime = -1L;
            long userTime = -1L;
            if (threadMXBean.isThreadCpuTimeSupported() && threadMXBean.isThreadCpuTimeEnabled()) {
                JThreadInfo oldThread = oldThreadInfoMap.get(threadInfo.getThreadId());
                if (oldThread == null) {
                    cpuTime = threadMXBean.getThreadCpuTime(threadId);
                    userTime = threadMXBean.getThreadUserTime(threadId);
                }
                else {
                    cpuTime = threadMXBean.getThreadCpuTime(threadId) - oldThread.getCpuTime();
                    userTime = threadMXBean.getThreadUserTime(threadId) - oldThread.getUserTime();
                }
            }
            jThreadInfos.add(new JThreadInfo(cpuTime, userTime, threadInfo));
            switch (threadInfo.getThreadState()) {
                case RUNNABLE:
                    runnableThreads++;
                    break;
                case BLOCKED:
                    blockedThreads++;

View Full Code Here

            this.threadSortOrder = threadSortOrder;
        }


        @Override
        public int compare(JThreadInfo jt1, JThreadInfo jt2) {
            ThreadInfo o1 = jt1.getThreadInfo();
            ThreadInfo o2 = jt2.getThreadInfo();
            if ("cpu".equals(threadSortOrder)) {
                int result = (int) (jt2.getCpuTime() - jt1.getCpuTime());
                if (result == 0) {
                    return compareId(o1, o2);
                }
                return result;
            }
            else if ("name".equals(threadSortOrder)) {
                return compareName(o1, o2);
            }
            else {
                // state
                if (o1.getThreadState().equals(o2.getThreadState())) {
                    return compareName(o1, o2);
                }
                else {
                    return (int) threadStateOrdering.get(o1.getThreadState())
                            - threadStateOrdering.get(o2.getThreadState());
                }
            }
        }

View Full Code Here

            if ( null != threads ) {
                StringBuffer sb = new StringBuffer( 256 );
                ThreadInfo[] infos = threadMXBean.getThreadInfo( threads, Integer.MAX_VALUE );


                for (int i = 0; i < infos.length; i ++) {
                    ThreadInfo info = infos[i];
                    sb.append( info.getThreadName() )
                        .append( " blocked on " )
                        .append( info.getLockName() )
                        .append( " owned by " )
                        .append( info.getLockOwnerName() )
                        .append( "\n" );
                }


                for (int i = 0; i < infos.length; i ++) {
                    ThreadInfo info = infos[i];
                    sb.append( "\nStack for " ).append( info.getThreadName() ).append( "\n" );
                    StackTraceElement[] stackTrace = info.getStackTrace();
                    for (int j = 0; j < stackTrace.length; j ++) {
                        sb.append( "\t" ).append( stackTrace[j] ).append( "\n" );
                    }
                }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of java.lang.management.ThreadInfo

biz.paluch.logging.gelf.jul.JulLogEvent

com.aelitis.azureus.core.util.AEThreadMonitor

com.alibaba.druid.benckmark.pool.Case1

com.alibaba.druid.benckmark.pool.Case2

com.alibaba.druid.benckmark.pool.Case4

com.alibaba.jstorm.metric.MetricJstack

com.carrotsearch.junitbenchmarks.BenchmarkStatement$BaseEvaluator

com.codahale.metrics.jvm.ThreadDeadlockDetectorTest

com.codahale.metrics.jvm.ThreadDump

com.custardsource.parfait.benchmark.BlockedMetricCollector

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.

Examples of java.lang.management.ThreadInfo

General thread information

Execution information

Synchronization Statistics

MXBean Mapping

Related Classes of java.lang.management.ThreadInfo