import com.sun.management.ThreadMXBean; //导入依赖的package包/类
@Override
public void run() {
    while (!isInterrupted()) {
        ThreadMXBean threadMXBean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
        for (long threadId : threadMXBean.getAllThreadIds()) {
            ThreadInfo info = threadMXBean.getThreadInfo(threadId);
            ThreadPrevValues prevValues = getPrevValues(threadId);
            long cpuTime = threadMXBean.getThreadCpuTime(threadId);
            long allocatedBytes = threadMXBean.getThreadAllocatedBytes(threadId);

            System.out.println(info.getThreadName() +
                " CPU time: " + prevValues.getDeltaCPUTime(cpuTime)  +
                " Allocated bytes: " + prevValues.getDeltaBytes(allocatedBytes));

            prevValues.update(cpuTime, allocatedBytes);
        }

        delaySleep();
    }

    System.out.println("ThreadStateLogger stopped");
}
 

import com.sun.management.ThreadMXBean; //导入依赖的package包/类
private ThreadMXBean getThreadMxBean()
{
   if (ProcessingValve.threadMxBean == null)
   {
      ThreadMXBean tmxBean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
      if (!tmxBean.isCurrentThreadCpuTimeSupported())
      {
         throw new UnsupportedOperationException("Thread CPU monitoring not supported.");
      }
      if (tmxBean.isThreadCpuTimeSupported() && !tmxBean.isThreadCpuTimeEnabled())
      {
         tmxBean.setThreadCpuTimeEnabled(true);
      }
      if (tmxBean.isThreadAllocatedMemorySupported() && !tmxBean.isThreadAllocatedMemoryEnabled())
      {
         tmxBean.setThreadAllocatedMemoryEnabled(true);
      }

      ProcessingValve.threadMxBean = tmxBean;
   }
   return ProcessingValve.threadMxBean;
}
 

import com.sun.management.ThreadMXBean; //导入依赖的package包/类
/**
 * Set the session for the thread.
 * @param session Service session.
 */
public final void setSession(ServiceSession session) {
    if(this.session != null) {
        //Remove the status of the current thread stored into the old session
        this.session.endThread();
    }

    if(session != null) {
        //Start the status of the current thread into the new session.
        session.startThread();

        //Init the counters
        setInitialAllocatedMemory(((ThreadMXBean)ManagementFactory.getThreadMXBean()).
                getThreadAllocatedBytes(Thread.currentThread().getId()));
        setInitialTime(ManagementFactory.getThreadMXBean().getCurrentThreadCpuTime());

        //Init the max allocated memory value for thread
        configureMaxAllocatedMemory(SystemProperties.getLong(SystemProperties.Service.MAX_ALLOCATED_MEMORY_FOR_THREAD));

        //Init the max execution time value for thread
        configureMaxExecutionTime(SystemProperties.getLong(SystemProperties.Service.MAX_EXECUTION_TIME_FOR_THREAD));
    }

    this.session = session;
}
 

import com.sun.management.ThreadMXBean; //导入依赖的package包/类
/**
 * Checks if threads other then the current thread were allocating objects
 * after baselinedThreadMemoryUsage call.
 *
 * If baselinedThreadMemoryUsage was not called, then this method will return
 * {@code false}.
 */
public boolean areOtherThreadsAllocatedMemory() {
    if (baselinedThreadMemoryUsage == null) {
        return false;
    }

    ThreadMXBean bean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
    long currentMemoryAllocation[]
            = bean.getThreadAllocatedBytes(threadIds);
    boolean otherThreadsAllocatedMemory = false;

    System.out.println("Verifying amount of memory allocated by threads:");
    for (int i = 0; i < threadIds.length; i++) {
        System.out.format("Thread %d%nbaseline allocation: %d"
                        + "%ncurrent allocation:%d%n", threadIds[i],
                baselinedThreadMemoryUsage[i], currentMemoryAllocation[i]);
        System.out.println(bean.getThreadInfo(threadIds[i]));

        long bytesAllocated = Math.abs(currentMemoryAllocation[i]
                - baselinedThreadMemoryUsage[i]);
        if (bytesAllocated > 0
                && threadIds[i] != Thread.currentThread().getId()) {
            otherThreadsAllocatedMemory = true;
        }
    }

    return otherThreadsAllocatedMemory;
}
 

import com.sun.management.ThreadMXBean; //导入依赖的package包/类
@Override
public void run() {
    while (!isInterrupted()) {
        ThreadMXBean threadMXBean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
        System.out.println(">>>>>>>>>>> Dumping threads");
        ThreadInfo[] info = threadMXBean.dumpAllThreads(true, true);
        System.out.println(Arrays.toString(info));

        delaySleep();
    }

    System.out.println("ThreadSampler stopped");
}
 

import com.sun.management.ThreadMXBean; //导入依赖的package包/类
public static void main(String[] args) {
    System.out.println("Threads");
    ThreadMXBean threadMBean = (ThreadMXBean) ManagementFactory.getThreadMXBean();

    System.out.println("Thread count = " + threadMBean.getThreadCount());
    System.out.println("Thread IDs = " + Arrays.toString(threadMBean.getAllThreadIds()));

    System.out.println(">>>>> Thread INFO");
    ThreadInfo[] threads = threadMBean.dumpAllThreads(true, true);
    for (ThreadInfo thread : threads) {
        System.out.println(thread);
    }

    System.out.println(">>>>> Thread INFO detailed");
    for (long threadId : threadMBean.getAllThreadIds()) {
        ThreadInfo threadInfo = threadMBean.getThreadInfo(threadId, 100);
        long cpuTime = threadMBean.getThreadCpuTime(threadId);
        long userTime = threadMBean.getThreadUserTime(threadId);
        long allocatedBytes = threadMBean.getThreadAllocatedBytes(threadId);
        System.out.println(threadInfo);
        System.out.println("CPU Time: " + cpuTime + ", USER time: " + userTime + ", Allocated bytes: " + allocatedBytes);
    }

    // Getting stack-traces of the current thread
    System.out.print(">> current thread: " + Thread.currentThread().getName() + "\n");
    for (StackTraceElement element : Thread.currentThread().getStackTrace()) {
        System.out.println(element);
    }
}
 

import com.sun.management.ThreadMXBean; //导入依赖的package包/类
public AllocationMonitor( final Thread benchmarkThread ) {
	//noinspection SuspiciousToArrayCall
	gcMXBeans = ManagementFactory.getGarbageCollectorMXBeans().toArray( new GarbageCollectorMXBean[0] );
	threadMXBean = ( ThreadMXBean ) ManagementFactory.getThreadMXBean();

	this.benchmarkThreadId = benchmarkThread.getId();
}
 

import com.sun.management.ThreadMXBean; //导入依赖的package包/类
/**
 * Verify if the current thread allocate more bytes that the max configured.
 * @throws Throwable Throws a run time exception.
 */
public static void checkAllocatedMemory() throws Throwable {
    ServiceThread serviceThread = (ServiceThread) Thread.currentThread();
    if(serviceThread.getAccumulatedAllocatedMemory() > serviceThread.getMaxAllocatedMemory()) {

        //Reset the initial value for the current thread in order to
        //continue with the throwable handling
        serviceThread.setInitialAllocatedMemory(((ThreadMXBean)ManagementFactory.getThreadMXBean()).
                getThreadAllocatedBytes(Thread.currentThread().getId()));

        throw new RuntimeException("Max memory allocated for thread exceeded");
    }
}
 

import com.sun.management.ThreadMXBean; //导入依赖的package包/类
private static long getThreadAllocatedBytes() {
    ThreadMXBean thread = (ThreadMXBean) ManagementFactory.getThreadMXBean();
    return thread.getThreadAllocatedBytes(currentThread().getId());
}
 

import com.sun.management.ThreadMXBean; //导入依赖的package包/类
/**
 * Baselines amount of memory allocated by each thread.
 */
public void baselineMemoryAllocation() {
    ThreadMXBean bean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
    threadIds = bean.getAllThreadIds();
    baselinedThreadMemoryUsage = bean.getThreadAllocatedBytes(threadIds);
}
 

import com.sun.management.ThreadMXBean; //导入依赖的package包/类
private static long getThreadAllocatedBytes() {
    ThreadMXBean thread = (ThreadMXBean) Management.getThreadMXBean();
    return thread.getThreadAllocatedBytes(currentThread().getId());
}
 

import com.sun.management.ThreadMXBean; //导入依赖的package包/类
public final Long getAccumulatedAllocatedMemory() {
    return ((ThreadMXBean)ManagementFactory.getThreadMXBean()).
            getThreadAllocatedBytes(Thread.currentThread().getId()) - getInitialAllocatedMemory();
}