com.sun.management.ThreadMXBean Java Examples

/**
 * 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()));

        if(SystemProperties.getBoolean(SystemProperties.Service.MAX_ALLOCATED_MEMORY_EXCEEDED_THROWS_EXCEPTION)) {
            throw new RuntimeException("Max memory allocated for thread exceeded");
        } else {
            Log.w(SystemProperties.get("SERVICE_THREAD"), "Max memory allocated for thread exceeded");
        }
    }
}
 

/**
 * 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;
}
 

/**
 * 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;
}
 

/**
 * Asserts that `supplier.get` doesn't allocate more than `bytes` bytes.
 * This is limited to the current thread and cannot account for memory accounted in other threads.
 */
public static <T> T assertMaxBytesAllocated(long bytes, Supplier<T> supplier) {
    ThreadMXBean threadMXBean = ManagementFactory.getPlatformMXBean(ThreadMXBean.class);
    long threadId = Thread.currentThread().getId();
    long allocatedBytesBegin = threadMXBean.getThreadAllocatedBytes(threadId);
    T t = supplier.get();
    long allocatedBytesAfter = threadMXBean.getThreadAllocatedBytes(threadId);
    long allocatedBytes = allocatedBytesAfter - allocatedBytesBegin;
    assertThat(allocatedBytes, Matchers.lessThanOrEqualTo(bytes));
    return t;
}
 

/**
 * 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;
}
 

/**
 * 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;
}
 

/**
 * 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;
}
 

static void testCompareWithMXBean() throws Throwable {
    Duration testRunTime = Duration.ofMillis(eventPeriodMillis * cpuConsumerRunFactor);
    CyclicBarrier barrier = new CyclicBarrier(2);
    CpuConsumingThread thread = new CpuConsumingThread(testRunTime, barrier);
    thread.start();

    List<RecordedEvent> beforeEvents = generateEvents(2, barrier);
    verifyPerThreadInvariant(beforeEvents, cpuConsumerThreadName);

    // Run a second single pass
    barrier.await();
    barrier.await();

    ThreadMXBean bean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
    Duration cpuTime = Duration.ofNanos(bean.getThreadCpuTime(thread.getId()));
    Duration userTime = Duration.ofNanos(bean.getThreadUserTime(thread.getId()));

    // Check something that should hold even in the presence of unfortunate scheduling
    Asserts.assertGreaterThanOrEqual(cpuTime.toMillis(), eventPeriodMillis);
    Asserts.assertGreaterThanOrEqual(userTime.toMillis(), eventPeriodMillis);

    Duration systemTimeBefore = getAccumulatedTime(beforeEvents, cpuConsumerThreadName, "system");
    Duration userTimeBefore = getAccumulatedTime(beforeEvents, cpuConsumerThreadName, "user");
    Duration cpuTimeBefore = userTimeBefore.plus(systemTimeBefore);

    Asserts.assertLessThan(cpuTimeBefore, cpuTime);
    Asserts.assertLessThan(userTimeBefore, userTime);
    Asserts.assertGreaterThan(cpuTimeBefore, Duration.ZERO);

    thread.interrupt();
    thread.join();
}
 

public static void main(String[] args) {
        ThreadMXBean threadMXBean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
        long[] threadIds = threadMXBean.getAllThreadIds();

        for (long threadId : threadIds) {
//            ThreadInfo threadInfo = threadMXBean.getThreadInfo(threadId);
//            System.out.println(threadInfo.toString());
            long bytes = threadMXBean.getThreadAllocatedBytes(threadId);
            long kBytes = bytes / 1024;
            System.out.printf("线程[ID:%d] 分配内存： %s KB\n", threadId, kBytes);
        }

    }
 

public synchronized ThreadMXBean getThreadMXBean() throws IOException {
	if (hasPlatformMXBeans && threadMBean == null) {
		threadMBean = JMX.newMXBeanProxy(server, createBeanName(ManagementFactory.THREAD_MXBEAN_NAME),
				ThreadMXBean.class);
	}
	return threadMBean;
}
 

public synchronized ThreadMXBean getThreadMXBean() throws IOException {
	if (hasPlatformMXBeans && threadMBean == null) {
		threadMBean = JMX.newMXBeanProxy(server, createBeanName(ManagementFactory.THREAD_MXBEAN_NAME),
				ThreadMXBean.class);
	}
	return threadMBean;
}
 

/**
 * 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;
}
 

/**
 * 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;
}
 

static void testCompareWithMXBean() throws Throwable {
    Duration testRunTime = Duration.ofMillis(eventPeriodMillis * cpuConsumerRunFactor);
    CyclicBarrier barrier = new CyclicBarrier(2);
    CpuConsumingThread thread = new CpuConsumingThread(testRunTime, barrier);
    thread.start();

    List<RecordedEvent> beforeEvents = generateEvents(2, barrier);
    verifyPerThreadInvariant(beforeEvents, cpuConsumerThreadName);

    // Run a second single pass
    barrier.await();
    barrier.await();

    ThreadMXBean bean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
    Duration cpuTime = Duration.ofNanos(bean.getThreadCpuTime(thread.getId()));
    Duration userTime = Duration.ofNanos(bean.getThreadUserTime(thread.getId()));

    // Check something that should hold even in the presence of unfortunate scheduling
    Asserts.assertGreaterThanOrEqual(cpuTime.toMillis(), eventPeriodMillis);
    Asserts.assertGreaterThanOrEqual(userTime.toMillis(), eventPeriodMillis);

    Duration systemTimeBefore = getAccumulatedTime(beforeEvents, cpuConsumerThreadName, "system");
    Duration userTimeBefore = getAccumulatedTime(beforeEvents, cpuConsumerThreadName, "user");
    Duration cpuTimeBefore = userTimeBefore.plus(systemTimeBefore);

    Asserts.assertLessThan(cpuTimeBefore, cpuTime);
    Asserts.assertLessThan(userTimeBefore, userTime);
    Asserts.assertGreaterThan(cpuTimeBefore, Duration.ZERO);

    thread.interrupt();
    thread.join();
}
 

static void testCompareWithMXBean() throws Throwable {
    Recording recording = new Recording();

    recording.enable(EventNames.ThreadCPULoad).withPeriod(Duration.ofMillis(eventPeriodMillis));
    recording.start();

    Duration testRunTime = Duration.ofMillis(eventPeriodMillis * cpuConsumerRunFactor);
    CyclicBarrier barrier = new CyclicBarrier(2);
    CpuConsumingThread thread = new CpuConsumingThread(testRunTime, barrier);

    // Run a single pass
    thread.start();
    barrier.await();
    barrier.await();

    recording.stop();
    List<RecordedEvent> beforeEvents = Events.fromRecording(recording);

    verifyPerThreadInvariant(beforeEvents, cpuConsumerThreadName);

    // Run a second single pass
    barrier.await();
    barrier.await();

    ThreadMXBean bean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
    Duration cpuTime = Duration.ofNanos(bean.getThreadCpuTime(thread.getId()));
    Duration userTime = Duration.ofNanos(bean.getThreadUserTime(thread.getId()));

    // Check something that should hold even in the presence of unfortunate scheduling
    Asserts.assertGreaterThanOrEqual(cpuTime.toMillis(), eventPeriodMillis);
    Asserts.assertGreaterThanOrEqual(userTime.toMillis(), eventPeriodMillis);

    Duration systemTimeBefore = getAccumulatedTime(beforeEvents, cpuConsumerThreadName, "system");
    Duration userTimeBefore = getAccumulatedTime(beforeEvents, cpuConsumerThreadName, "user");
    Duration cpuTimeBefore = userTimeBefore.plus(systemTimeBefore);

    Asserts.assertLessThan(cpuTimeBefore, cpuTime);
    Asserts.assertLessThan(userTimeBefore, userTime);
    Asserts.assertGreaterThan(cpuTimeBefore, Duration.ZERO);

    thread.interrupt();
    thread.join();
}
 

public ThreadMXBean getThreadMXBean() throws IOException {
	return jmxClient.getThreadMXBean();
}
 

/**
 * Baselines amount of memory allocated by each thread.
 */
public void baselineMemoryAllocation() {
    ThreadMXBean bean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
    threadIds = bean.getAllThreadIds();
    baselinedThreadMemoryUsage = bean.getThreadAllocatedBytes(threadIds);
}
 

public final Long getAccumulatedAllocatedMemory() {
    return ((ThreadMXBean)ManagementFactory.getThreadMXBean()).
            getThreadAllocatedBytes(Thread.currentThread().getId()) - getInitialAllocatedMemory();
}
 

private long getThreadAllocatedBytes() {
    ThreadMXBean bean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
    return bean.getThreadAllocatedBytes(Thread.currentThread().getId());
}
 

/**
 * Baselines amount of memory allocated by each thread.
 */
public void baselineMemoryAllocation() {
    ThreadMXBean bean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
    threadIds = bean.getAllThreadIds();
    baselinedThreadMemoryUsage = bean.getThreadAllocatedBytes(threadIds);
}
 

/**
 * Baselines amount of memory allocated by each thread.
 */
public void baselineMemoryAllocation() {
    ThreadMXBean bean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
    threadIds = bean.getAllThreadIds();
    baselinedThreadMemoryUsage = bean.getThreadAllocatedBytes(threadIds);
}
 

private static long getThreadAllocatedBytes() {
    ThreadMXBean thread = (ThreadMXBean) Management.getThreadMXBean();
    return thread.getThreadAllocatedBytes(currentThread().getId());
}
 

/**
 * Baselines amount of memory allocated by each thread.
 */
public void baselineMemoryAllocation() {
    ThreadMXBean bean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
    threadIds = bean.getAllThreadIds();
    baselinedThreadMemoryUsage = bean.getThreadAllocatedBytes(threadIds);
}
 

/**
 * Baselines amount of memory allocated by each thread.
 */
public void baselineMemoryAllocation() {
    ThreadMXBean bean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
    threadIds = bean.getAllThreadIds();
    baselinedThreadMemoryUsage = bean.getThreadAllocatedBytes(threadIds);
}
 

private long getThreadAllocatedBytes() {
    ThreadMXBean bean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
    return bean.getThreadAllocatedBytes(Thread.currentThread().getId());
}
 

private long getThreadAllocatedBytes() {
    ThreadMXBean bean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
    return bean.getThreadAllocatedBytes(Thread.currentThread().getId());
}
 

/**
 * Baselines amount of memory allocated by each thread.
 */
public void baselineMemoryAllocation() {
    ThreadMXBean bean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
    threadIds = bean.getAllThreadIds();
    baselinedThreadMemoryUsage = bean.getThreadAllocatedBytes(threadIds);
}