shuiyu1123
a51854455b
- android/ 167个模块 (app/content/os/view/widget/graphics/media/hardware/net/telephony/provider等) - java/ 35个模块 (lang/io/util/net/nio/security/crypto/sql/beans/rmi/awt等) - javax/ 4个模块 (net/crypto/security/sql) - org/ 5个模块 (json/w3c_dom/xml_sax/xml_pull/apache_http) - dalvik/ 1个模块 (system) - ~3053个类/接口，方法签名完全对齐Android SDK - 桌面跨平台运行 (Windows/macOS/Linux) - 修复所有导入错误和Python关键字冲突
830 lines
24 KiB
Python
830 lines
24 KiB
Python
"""
|
|
Java java.lang.management standard library APIs implemented in Python.
|
|
java.lang.management package - ManagementFactory, MXBeans, ThreadInfo, etc.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from .._core import Stub
|
|
from ..java.lang import RuntimeException, StackTraceElement
|
|
import typing as _typing
|
|
import time as _time
|
|
import os as _os
|
|
import sys as _sys
|
|
import threading as _threading
|
|
import platform as _platform
|
|
|
|
__all__ = [
|
|
"ManagementFactory", "MemoryMXBean", "MemoryUsage", "MemoryType",
|
|
"MemoryPoolMXBean", "MemoryManagerMXBean", "GarbageCollectorMXBean",
|
|
"ThreadMXBean", "RuntimeMXBean", "ClassLoadingMXBean",
|
|
"OperatingSystemMXBean", "CompilationMXBean",
|
|
"PlatformLoggingMXBean", "PlatformManagedObject",
|
|
"ManagementPermission", "LockInfo", "MonitorInfo", "ThreadInfo",
|
|
]
|
|
|
|
|
|
# ============================================================
|
|
# ManagementPermission
|
|
# ============================================================
|
|
|
|
class ManagementPermission(Stub):
|
|
"""java.lang.management.ManagementPermission"""
|
|
def __init__(self, name, actions=None):
|
|
super().__init__()
|
|
self._name = name
|
|
self._actions = actions
|
|
|
|
def getName(self):
|
|
return self._name
|
|
|
|
def getActions(self):
|
|
return self._actions or ""
|
|
|
|
def implies(self, permission):
|
|
return True
|
|
|
|
|
|
# ============================================================
|
|
# MemoryType
|
|
# ============================================================
|
|
|
|
class MemoryType(Stub):
|
|
"""java.lang.management.MemoryType"""
|
|
def __init__(self, name):
|
|
super().__init__()
|
|
self._name = name
|
|
|
|
def toString(self):
|
|
return self._name
|
|
|
|
HEAP = None
|
|
NON_HEAP = None
|
|
|
|
|
|
MemoryType.HEAP = MemoryType("HEAP")
|
|
MemoryType.NON_HEAP = MemoryType("NON_HEAP")
|
|
|
|
|
|
# ============================================================
|
|
# MemoryUsage
|
|
# ============================================================
|
|
|
|
class MemoryUsage(Stub):
|
|
"""java.lang.management.MemoryUsage"""
|
|
def __init__(self, init, used, committed, max_val):
|
|
super().__init__()
|
|
self._init = init
|
|
self._used = used
|
|
self._committed = committed
|
|
self._max = max_val
|
|
|
|
def getInit(self):
|
|
return self._init
|
|
|
|
def getUsed(self):
|
|
return self._used
|
|
|
|
def getCommitted(self):
|
|
return self._committed
|
|
|
|
def getMax(self):
|
|
return self._max
|
|
|
|
def toString(self):
|
|
return (f"init={self._init} used={self._used} "
|
|
f"committed={self._committed} max={self._max}")
|
|
|
|
|
|
# ============================================================
|
|
# LockInfo
|
|
# ============================================================
|
|
|
|
class LockInfo(Stub):
|
|
"""java.lang.management.LockInfo"""
|
|
def __init__(self, class_name, identity_hash_code):
|
|
super().__init__()
|
|
self._class_name = class_name
|
|
self._identity_hash_code = identity_hash_code
|
|
|
|
def getClassName(self):
|
|
return self._class_name
|
|
|
|
def getIdentityHashCode(self):
|
|
return self._identity_hash_code
|
|
|
|
def toString(self):
|
|
return f"{self._class_name}@{self._identity_hash_code:x}"
|
|
|
|
|
|
# ============================================================
|
|
# MonitorInfo
|
|
# ============================================================
|
|
|
|
class MonitorInfo(LockInfo):
|
|
"""java.lang.management.MonitorInfo"""
|
|
def __init__(self, class_name, identity_hash_code,
|
|
locked_stack_depth, locked_stack_frame):
|
|
super().__init__(class_name, identity_hash_code)
|
|
self._locked_stack_depth = locked_stack_depth
|
|
self._locked_stack_frame = locked_stack_frame
|
|
|
|
def getLockedStackDepth(self):
|
|
return self._locked_stack_depth
|
|
|
|
def getLockedStackFrame(self):
|
|
return self._locked_stack_frame
|
|
|
|
def toString(self):
|
|
return (f"MonitorInfo[{self._class_name}@{self._identity_hash_code:x}, "
|
|
f"depth={self._locked_stack_depth}]")
|
|
|
|
|
|
# ============================================================
|
|
# ThreadInfo
|
|
# ============================================================
|
|
|
|
class ThreadInfo(Stub):
|
|
"""java.lang.management.ThreadInfo"""
|
|
def __init__(self, thread_id=0, thread_name="", thread_state="RUNNABLE",
|
|
blocked_count=0, blocked_time=-1, waited_count=0, waited_time=-1,
|
|
lock_name=None, lock_owner_id=-1, lock_owner_name=None,
|
|
in_native=False, suspended=False, stack_trace=None,
|
|
locked_monitors=None, locked_synchronizers=None,
|
|
daemon=False, priority=5):
|
|
super().__init__()
|
|
self._thread_id = thread_id
|
|
self._thread_name = thread_name
|
|
self._thread_state = thread_state
|
|
self._blocked_count = blocked_count
|
|
self._blocked_time = blocked_time
|
|
self._waited_count = waited_count
|
|
self._waited_time = waited_time
|
|
self._lock_name = lock_name
|
|
self._lock_owner_id = lock_owner_id
|
|
self._lock_owner_name = lock_owner_name
|
|
self._in_native = in_native
|
|
self._suspended = suspended
|
|
self._stack_trace = stack_trace or []
|
|
self._locked_monitors = locked_monitors or []
|
|
self._locked_synchronizers = locked_synchronizers or []
|
|
self._daemon = daemon
|
|
self._priority = priority
|
|
|
|
def getThreadId(self):
|
|
return self._thread_id
|
|
|
|
def getThreadName(self):
|
|
return self._thread_name
|
|
|
|
def getThreadState(self):
|
|
return self._thread_state
|
|
|
|
def getBlockedCount(self):
|
|
return self._blocked_count
|
|
|
|
def getBlockedTime(self):
|
|
return self._blocked_time
|
|
|
|
def getWaitedCount(self):
|
|
return self._waited_count
|
|
|
|
def getWaitedTime(self):
|
|
return self._waited_time
|
|
|
|
def getLockName(self):
|
|
return self._lock_name
|
|
|
|
def getLockOwnerId(self):
|
|
return self._lock_owner_id
|
|
|
|
def getLockOwnerName(self):
|
|
return self._lock_owner_name
|
|
|
|
def isInNative(self):
|
|
return self._in_native
|
|
|
|
def isSuspended(self):
|
|
return self._suspended
|
|
|
|
def getStackTrace(self):
|
|
return self._stack_trace
|
|
|
|
def getLockedMonitors(self):
|
|
return self._locked_monitors
|
|
|
|
def getLockedSynchronizers(self):
|
|
return self._locked_synchronizers
|
|
|
|
def isDaemon(self):
|
|
return self._daemon
|
|
|
|
def getPriority(self):
|
|
return self._priority
|
|
|
|
def toString(self):
|
|
return (f"ThreadInfo[id={self._thread_id}, name={self._thread_name}, "
|
|
f"state={self._thread_state}]")
|
|
|
|
|
|
# ============================================================
|
|
# PlatformManagedObject
|
|
# ============================================================
|
|
|
|
class PlatformManagedObject(Stub):
|
|
"""java.lang.management.PlatformManagedObject"""
|
|
def getObjectName(self):
|
|
return None
|
|
|
|
|
|
# ============================================================
|
|
# MemoryMXBean
|
|
# ============================================================
|
|
|
|
class MemoryMXBean(PlatformManagedObject):
|
|
"""java.lang.management.MemoryMXBean"""
|
|
def __init__(self):
|
|
super().__init__()
|
|
import psutil as _psutil
|
|
self._psutil_available = False
|
|
try:
|
|
import psutil
|
|
self._psutil = psutil
|
|
self._psutil_available = True
|
|
except ImportError:
|
|
self._psutil_available = False
|
|
|
|
def getHeapMemoryUsage(self):
|
|
if self._psutil_available:
|
|
mem = self._psutil.virtual_memory()
|
|
return MemoryUsage(mem.total, mem.used, mem.available, mem.total)
|
|
return MemoryUsage(0, 0, 0, 0)
|
|
|
|
def getNonHeapMemoryUsage(self):
|
|
return MemoryUsage(0, 0, 0, 0)
|
|
|
|
def getObjectPendingFinalizationCount(self):
|
|
return 0
|
|
|
|
def isVerbose(self):
|
|
return False
|
|
|
|
def setVerbose(self, value):
|
|
pass
|
|
|
|
def gc(self):
|
|
import gc
|
|
gc.collect()
|
|
|
|
|
|
# ============================================================
|
|
# MemoryPoolMXBean
|
|
# ============================================================
|
|
|
|
class MemoryPoolMXBean(PlatformManagedObject):
|
|
"""java.lang.management.MemoryPoolMXBean"""
|
|
def __init__(self, name="", pool_type=MemoryType.HEAP):
|
|
super().__init__()
|
|
self._name = name
|
|
self._type = pool_type
|
|
self._usage = MemoryUsage(0, 0, 0, 0)
|
|
self._peak_usage = MemoryUsage(0, 0, 0, 0)
|
|
self._collection_usage = None
|
|
self._valid = True
|
|
self._threshold = 0
|
|
self._collection_threshold = 0
|
|
self._threshold_supported = False
|
|
self._collection_threshold_supported = False
|
|
|
|
def getName(self):
|
|
return self._name
|
|
|
|
def getType(self):
|
|
return self._type
|
|
|
|
def getUsage(self):
|
|
import psutil
|
|
try:
|
|
mem = psutil.virtual_memory()
|
|
self._usage = MemoryUsage(mem.total, mem.used, mem.available, mem.total)
|
|
except ImportError:
|
|
pass
|
|
return self._usage
|
|
|
|
def getPeakUsage(self):
|
|
return self._peak_usage
|
|
|
|
def resetPeakUsage(self):
|
|
self._peak_usage = MemoryUsage(0, 0, 0, 0)
|
|
|
|
def isValid(self):
|
|
return self._valid
|
|
|
|
def getCollectionUsage(self):
|
|
return self._collection_usage
|
|
|
|
def getUsageThreshold(self):
|
|
return self._threshold
|
|
|
|
def setUsageThreshold(self, threshold):
|
|
self._threshold = threshold
|
|
self._threshold_supported = True
|
|
|
|
def isUsageThresholdSupported(self):
|
|
return self._threshold_supported
|
|
|
|
def isUsageThresholdExceeded(self):
|
|
return self._usage.getUsed() > self._threshold if self._threshold > 0 else False
|
|
|
|
def getUsageThresholdCount(self):
|
|
return 0
|
|
|
|
def getCollectionUsageThreshold(self):
|
|
return self._collection_threshold
|
|
|
|
def setCollectionUsageThreshold(self, threshold):
|
|
self._collection_threshold = threshold
|
|
self._collection_threshold_supported = True
|
|
|
|
def isCollectionUsageThresholdSupported(self):
|
|
return self._collection_threshold_supported
|
|
|
|
def isCollectionUsageThresholdExceeded(self):
|
|
return False
|
|
|
|
def getCollectionUsageThresholdCount(self):
|
|
return 0
|
|
|
|
def getMemoryManagerNames(self):
|
|
return []
|
|
|
|
def toString(self):
|
|
return f"MemoryPoolMXBean[name={self._name}, type={self._type}]"
|
|
|
|
|
|
# ============================================================
|
|
# MemoryManagerMXBean
|
|
# ============================================================
|
|
|
|
class MemoryManagerMXBean(PlatformManagedObject):
|
|
"""java.lang.management.MemoryManagerMXBean"""
|
|
def __init__(self, name=""):
|
|
super().__init__()
|
|
self._name = name
|
|
self._valid = True
|
|
self._pool_names = []
|
|
|
|
def getName(self):
|
|
return self._name
|
|
|
|
def isValid(self):
|
|
return self._valid
|
|
|
|
def getMemoryPoolNames(self):
|
|
return self._pool_names
|
|
|
|
def toString(self):
|
|
return f"MemoryManagerMXBean[name={self._name}]"
|
|
|
|
|
|
# ============================================================
|
|
# GarbageCollectorMXBean
|
|
# ============================================================
|
|
|
|
class GarbageCollectorMXBean(MemoryManagerMXBean):
|
|
"""java.lang.management.GarbageCollectorMXBean"""
|
|
def __init__(self, name=""):
|
|
super().__init__(name)
|
|
self._collection_count = 0
|
|
self._collection_time = 0
|
|
|
|
def getCollectionCount(self):
|
|
return self._collection_count
|
|
|
|
def getCollectionTime(self):
|
|
return self._collection_time
|
|
|
|
def toString(self):
|
|
return (f"GarbageCollectorMXBean[name={self._name}, "
|
|
f"collections={self._collection_count}, "
|
|
f"time={self._collection_time}ms]")
|
|
|
|
|
|
# ============================================================
|
|
# ThreadMXBean
|
|
# ============================================================
|
|
|
|
class ThreadMXBean(PlatformManagedObject):
|
|
"""java.lang.management.ThreadMXBean"""
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._thread_contention_monitoring_enabled = False
|
|
self._thread_cpu_time_enabled = False
|
|
self._thread_allocated_memory_enabled = False
|
|
|
|
def getThreadCount(self):
|
|
return _threading.active_count()
|
|
|
|
def getPeakThreadCount(self):
|
|
return _threading.active_count()
|
|
|
|
def getTotalStartedThreadCount(self):
|
|
return _threading.active_count()
|
|
|
|
def getDaemonThreadCount(self):
|
|
return 0
|
|
|
|
def getAllThreadIds(self):
|
|
return [t.ident for t in _threading.enumerate() if t.ident is not None]
|
|
|
|
def getThreadInfo(self, thread_id_or_ids, max_depth=None):
|
|
if isinstance(thread_id_or_ids, (list, tuple)):
|
|
return [self._build_thread_info(tid) for tid in thread_id_or_ids]
|
|
return self._build_thread_info(thread_id_or_ids)
|
|
|
|
def _build_thread_info(self, thread_id):
|
|
for t in _threading.enumerate():
|
|
if t.ident == thread_id:
|
|
return ThreadInfo(
|
|
thread_id=thread_id,
|
|
thread_name=t.name or "",
|
|
thread_state=t.name or "RUNNABLE",
|
|
)
|
|
return ThreadInfo(thread_id=thread_id, thread_name="")
|
|
|
|
def isThreadContentionMonitoringSupported(self):
|
|
return True
|
|
|
|
def isThreadContentionMonitoringEnabled(self):
|
|
return self._thread_contention_monitoring_enabled
|
|
|
|
def setThreadContentionMonitoringEnabled(self, enable):
|
|
self._thread_contention_monitoring_enabled = enable
|
|
|
|
def isCurrentThreadCpuTimeSupported(self):
|
|
return True
|
|
|
|
def isThreadCpuTimeEnabled(self):
|
|
return self._thread_cpu_time_enabled
|
|
|
|
def setThreadCpuTimeEnabled(self, enable):
|
|
self._thread_cpu_time_enabled = enable
|
|
|
|
def getCurrentThreadCpuTime(self):
|
|
return 0
|
|
|
|
def getCurrentThreadUserTime(self):
|
|
return 0
|
|
|
|
def getThreadCpuTime(self, thread_id):
|
|
return 0
|
|
|
|
def getThreadUserTime(self, thread_id):
|
|
return 0
|
|
|
|
def isObjectMonitorUsageSupported(self):
|
|
return True
|
|
|
|
def isSynchronizerUsageSupported(self):
|
|
return True
|
|
|
|
def findMonitorDeadlockedThreads(self):
|
|
return None
|
|
|
|
def findDeadlockedThreads(self):
|
|
return None
|
|
|
|
def resetPeakThreadCount(self):
|
|
pass
|
|
|
|
def getThreadAllocatedBytes(self, thread_id_or_ids):
|
|
if isinstance(thread_id_or_ids, (list, tuple)):
|
|
return [0] * len(thread_id_or_ids)
|
|
return 0
|
|
|
|
def isThreadAllocatedMemorySupported(self):
|
|
return True
|
|
|
|
def isThreadAllocatedMemoryEnabled(self):
|
|
return self._thread_allocated_memory_enabled
|
|
|
|
def setThreadAllocatedMemoryEnabled(self, enable):
|
|
self._thread_allocated_memory_enabled = enable
|
|
|
|
def getTotalThreadAllocatedBytes(self):
|
|
return 0
|
|
|
|
|
|
# ============================================================
|
|
# RuntimeMXBean
|
|
# ============================================================
|
|
|
|
class RuntimeMXBean(PlatformManagedObject):
|
|
"""java.lang.management.RuntimeMXBean"""
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._start_time = _time.time() * 1000
|
|
|
|
def getName(self):
|
|
return f"{_os.getpid()}@{_platform.node()}"
|
|
|
|
getVmName = lambda self: _platform.python_implementation()
|
|
getVmVersion = lambda self: _platform.python_version()
|
|
getVmVendor = lambda self: "Python Software Foundation"
|
|
getSpecName = lambda self: "Python Virtual Machine Specification"
|
|
getSpecVersion = lambda self: _sys.version
|
|
getSpecVendor = lambda self: "Python Software Foundation"
|
|
|
|
def getManagementSpecVersion(self):
|
|
return "1.0"
|
|
|
|
def getStartTime(self):
|
|
return self._start_time
|
|
|
|
def getUptime(self):
|
|
return (_time.time() * 1000) - self._start_time
|
|
|
|
def getInputArguments(self):
|
|
return _sys.argv[1:]
|
|
|
|
def getClassPath(self):
|
|
return _sys.path
|
|
|
|
def getBootClassPath(self):
|
|
return ""
|
|
|
|
def getLibraryPath(self):
|
|
return _os.environ.get("PATH", "")
|
|
|
|
def getSystemProperties(self):
|
|
return {
|
|
"java.version": _platform.python_version(),
|
|
"java.vendor": "Python",
|
|
"java.vm.version": _platform.python_version(),
|
|
"os.name": _platform.system(),
|
|
"os.arch": _platform.machine(),
|
|
"os.version": _platform.release(),
|
|
"user.dir": _os.getcwd(),
|
|
"user.home": _os.path.expanduser("~"),
|
|
"user.name": _os.environ.get("USER", ""),
|
|
"line.separator": "\n",
|
|
"file.separator": _os.sep,
|
|
"path.separator": _os.pathsep,
|
|
}
|
|
|
|
def isBootClassPathSupported(self):
|
|
return False
|
|
|
|
|
|
# ============================================================
|
|
# ClassLoadingMXBean
|
|
# ============================================================
|
|
|
|
class ClassLoadingMXBean(PlatformManagedObject):
|
|
"""java.lang.management.ClassLoadingMXBean"""
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._verbose = False
|
|
|
|
def getTotalLoadedClassCount(self):
|
|
return 0
|
|
|
|
def getLoadedClassCount(self):
|
|
return 0
|
|
|
|
def getUnloadedClassCount(self):
|
|
return 0
|
|
|
|
def isVerbose(self):
|
|
return self._verbose
|
|
|
|
def setVerbose(self, value):
|
|
self._verbose = value
|
|
|
|
|
|
# ============================================================
|
|
# OperatingSystemMXBean
|
|
# ============================================================
|
|
|
|
class OperatingSystemMXBean(PlatformManagedObject):
|
|
"""java.lang.management.OperatingSystemMXBean"""
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._available = False
|
|
try:
|
|
import psutil
|
|
self._psutil = psutil
|
|
self._available = True
|
|
except ImportError:
|
|
self._available = False
|
|
|
|
def getArch(self):
|
|
return _platform.machine()
|
|
|
|
def getAvailableProcessors(self):
|
|
return _os.cpu_count() or 1
|
|
|
|
def getSystemLoadAverage(self):
|
|
if self._available:
|
|
return self._psutil.getloadavg()[0]
|
|
return -1.0
|
|
|
|
def getName(self):
|
|
return _platform.system()
|
|
|
|
def getVersion(self):
|
|
return _platform.release()
|
|
|
|
def getProcessCpuTime(self):
|
|
return 0
|
|
|
|
def getCommittedVirtualMemorySize(self):
|
|
return 0
|
|
|
|
def getTotalSwapSpaceSize(self):
|
|
if self._available:
|
|
return self._psutil.swap_memory().total
|
|
return 0
|
|
|
|
def getFreeSwapSpaceSize(self):
|
|
if self._available:
|
|
return self._psutil.swap_memory().free
|
|
return 0
|
|
|
|
def getProcessCpuLoad(self):
|
|
return 0.0
|
|
|
|
def getSystemCpuLoad(self):
|
|
if self._available:
|
|
return self._psutil.cpu_percent(interval=0) / 100.0
|
|
return 0.0
|
|
|
|
def getTotalPhysicalMemorySize(self):
|
|
if self._available:
|
|
return self._psutil.virtual_memory().total
|
|
return 0
|
|
|
|
def getFreePhysicalMemorySize(self):
|
|
if self._available:
|
|
return self._psutil.virtual_memory().available
|
|
return 0
|
|
|
|
def getTotalDiskSpace(self):
|
|
return 0
|
|
|
|
def getFreeDiskSpace(self):
|
|
return 0
|
|
|
|
def getSystemUptime(self):
|
|
return _time.time() - _time.monotonic() + _time.monotonic()
|
|
|
|
|
|
# ============================================================
|
|
# CompilationMXBean
|
|
# ============================================================
|
|
|
|
class CompilationMXBean(PlatformManagedObject):
|
|
"""java.lang.management.CompilationMXBean"""
|
|
def getName(self):
|
|
return "CPython"
|
|
|
|
def isCompilationTimeMonitoringSupported(self):
|
|
return False
|
|
|
|
def getTotalCompilationTime(self):
|
|
return 0
|
|
|
|
|
|
# ============================================================
|
|
# PlatformLoggingMXBean
|
|
# ============================================================
|
|
|
|
class PlatformLoggingMXBean(PlatformManagedObject):
|
|
"""java.lang.management.PlatformLoggingMXBean"""
|
|
def getLoggerLevel(self, logger_name):
|
|
return ""
|
|
|
|
def setLoggerLevel(self, logger_name, level_name):
|
|
pass
|
|
|
|
def getParentLogger(self, logger_name):
|
|
return ""
|
|
|
|
def getLoggerNames(self):
|
|
return []
|
|
|
|
|
|
# ============================================================
|
|
# ManagementFactory
|
|
# ============================================================
|
|
|
|
class ManagementFactory(Stub):
|
|
"""java.lang.management.ManagementFactory"""
|
|
CLASS_LOADING_MXBEAN_NAME = "java.lang:type=ClassLoading"
|
|
COMPILATION_MXBEAN_NAME = "java.lang:type=Compilation"
|
|
GARBAGE_COLLECTOR_MXBEAN_DOMAIN_TYPE = "java.lang:type=GarbageCollector"
|
|
MEMORY_MANAGER_MXBEAN_DOMAIN_TYPE = "java.lang:type=MemoryManager"
|
|
MEMORY_MXBEAN_NAME = "java.lang:type=Memory"
|
|
MEMORY_POOL_MXBEAN_DOMAIN_TYPE = "java.lang:type=MemoryPool"
|
|
OPERATING_SYSTEM_MXBEAN_NAME = "java.lang:type=OperatingSystem"
|
|
RUNTIME_MXBEAN_NAME = "java.lang:type=Runtime"
|
|
THREAD_MXBEAN_NAME = "java.lang:type=Threading"
|
|
LOGGING_MXBEAN_NAME = "java.util.logging:type=Logging"
|
|
|
|
_memory_mxbean = None
|
|
_runtime_mxbean = None
|
|
_thread_mxbean = None
|
|
_class_loading_mxbean = None
|
|
_os_mxbean = None
|
|
_compilation_mxbean = None
|
|
_platform_logging_mxbean = None
|
|
_memory_pools = None
|
|
_memory_managers = None
|
|
_gc_mxbeans = None
|
|
|
|
@staticmethod
|
|
def getMemoryMXBean():
|
|
if ManagementFactory._memory_mxbean is None:
|
|
ManagementFactory._memory_mxbean = MemoryMXBean()
|
|
return ManagementFactory._memory_mxbean
|
|
|
|
@staticmethod
|
|
def getRuntimeMXBean():
|
|
if ManagementFactory._runtime_mxbean is None:
|
|
ManagementFactory._runtime_mxbean = RuntimeMXBean()
|
|
return ManagementFactory._runtime_mxbean
|
|
|
|
@staticmethod
|
|
def getThreadMXBean():
|
|
if ManagementFactory._thread_mxbean is None:
|
|
ManagementFactory._thread_mxbean = ThreadMXBean()
|
|
return ManagementFactory._thread_mxbean
|
|
|
|
@staticmethod
|
|
def getClassLoadingMXBean():
|
|
if ManagementFactory._class_loading_mxbean is None:
|
|
ManagementFactory._class_loading_mxbean = ClassLoadingMXBean()
|
|
return ManagementFactory._class_loading_mxbean
|
|
|
|
@staticmethod
|
|
def getOperatingSystemMXBean():
|
|
if ManagementFactory._os_mxbean is None:
|
|
ManagementFactory._os_mxbean = OperatingSystemMXBean()
|
|
return ManagementFactory._os_mxbean
|
|
|
|
@staticmethod
|
|
def getCompilationMXBean():
|
|
if ManagementFactory._compilation_mxbean is None:
|
|
ManagementFactory._compilation_mxbean = CompilationMXBean()
|
|
return ManagementFactory._compilation_mxbean
|
|
|
|
@staticmethod
|
|
def getPlatformLoggingMXBean():
|
|
if ManagementFactory._platform_logging_mxbean is None:
|
|
ManagementFactory._platform_logging_mxbean = PlatformLoggingMXBean()
|
|
return ManagementFactory._platform_logging_mxbean
|
|
|
|
@staticmethod
|
|
def getMemoryPoolMXBeans():
|
|
if ManagementFactory._memory_pools is None:
|
|
ManagementFactory._memory_pools = [
|
|
MemoryPoolMXBean("Code Cache", MemoryType.NON_HEAP),
|
|
MemoryPoolMXBean("Metaspace", MemoryType.NON_HEAP),
|
|
MemoryPoolMXBean("Compressed Class Space", MemoryType.NON_HEAP),
|
|
MemoryPoolMXBean("PS Eden Space", MemoryType.HEAP),
|
|
MemoryPoolMXBean("PS Survivor Space", MemoryType.HEAP),
|
|
MemoryPoolMXBean("PS Old Gen", MemoryType.HEAP),
|
|
]
|
|
return ManagementFactory._memory_pools
|
|
|
|
@staticmethod
|
|
def getMemoryManagerMXBeans():
|
|
if ManagementFactory._memory_managers is None:
|
|
ManagementFactory._memory_managers = [
|
|
MemoryManagerMXBean("CodeCacheManager"),
|
|
MemoryManagerMXBean("Metaspace Manager"),
|
|
MemoryManagerMXBean("PS Scavenge"),
|
|
MemoryManagerMXBean("PS MarkSweep"),
|
|
]
|
|
return ManagementFactory._memory_managers
|
|
|
|
@staticmethod
|
|
def getGarbageCollectorMXBeans():
|
|
if ManagementFactory._gc_mxbeans is None:
|
|
ManagementFactory._gc_mxbeans = [
|
|
GarbageCollectorMXBean("PS Scavenge"),
|
|
GarbageCollectorMXBean("PS MarkSweep"),
|
|
]
|
|
return ManagementFactory._gc_mxbeans
|
|
|
|
@staticmethod
|
|
def getPlatformMXBeans(interface_class):
|
|
return []
|
|
|
|
@staticmethod
|
|
def newPlatformMXBeanProxy(server_connection, mxbean_name, interface_class):
|
|
return None
|
|
|
|
@staticmethod
|
|
def getPlatformManagedObject(object_name):
|
|
return None |