<!DOCTYPE HTML>
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc (16) -->
<title>ExtendedOperatingSystemMXBeanImpl (OpenJ9 JDK 16)</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="description" content="declaration: module: jdk.management, package: com.ibm.lang.management.internal, class: ExtendedOperatingSystemMXBeanImpl">
<meta name="generator" content="javadoc/ClassWriterImpl">
<meta name="keywords" content="com.ibm.lang.management.internal.ExtendedOperatingSystemMXBeanImpl class">
<meta name="keywords" content="getInstance()">
<meta name="keywords" content="getFreePhysicalMemorySize()">
<meta name="keywords" content="getCpuLoad()">
<meta name="keywords" content="getTotalMemorySize()">
<meta name="keywords" content="getFreeMemorySize()">
<meta name="keywords" content="getFreeSwapSpaceSize()">
<meta name="keywords" content="getHardwareModel()">
<meta name="keywords" content="getProcessCpuLoad()">
<meta name="keywords" content="getProcessCpuTime()">
<meta name="keywords" content="getProcessCpuTimeByNS()">
<meta name="keywords" content="getProcessingCapacity()">
<meta name="keywords" content="getProcessPhysicalMemorySize()">
<meta name="keywords" content="getProcessPrivateMemorySize()">
<meta name="keywords" content="getCommittedVirtualMemorySize()">
<meta name="keywords" content="getProcessVirtualMemorySize()">
<meta name="keywords" content="getSystemCpuLoad()">
<meta name="keywords" content="getTotalPhysicalMemorySize()">
<meta name="keywords" content="getTotalPhysicalMemory()">
<meta name="keywords" content="getTotalSwapSpaceSize()">
<meta name="keywords" content="isHardwareEmulated()">
<meta name="keywords" content="retrieveMemoryUsage()">
<meta name="keywords" content="retrieveProcessorUsage()">
<meta name="keywords" content="retrieveTotalProcessorUsage()">
<meta name="keywords" content="getNotificationInfo()">
<meta name="keywords" content="isProcessRunning()">
<link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../../script-dir/jquery-ui.min.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../../../jquery-ui.overrides.css" title="Style">
<script type="text/javascript" src="../../../../../../script.js"></script>
<script type="text/javascript" src="../../../../../../script-dir/jquery-3.5.1.min.js"></script>
<script type="text/javascript" src="../../../../../../script-dir/jquery-ui.min.js"></script>
</head>
<body class="class-declaration-page">
<script type="text/javascript">var evenRowColor = "even-row-color";
var oddRowColor = "odd-row-color";
var tableTab = "table-tab";
var activeTableTab = "active-table-tab";
var pathtoroot = "../../../../../../";
loadScripts(document, 'script');</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="flex-box">
<header role="banner" class="flex-header">
<nav role="navigation">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="top-nav" id="navbar.top">
<div class="skip-nav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<div class="about-language"><div style="margin-top: 9px;"><strong>OpenJ9 JDK 16</strong></div></div>
<ul id="navbar.top.firstrow" class="nav-list" title="Navigation">
<li><a href="../../../../../../index.html">Overview</a></li>
<li><a href="../../../../../module-summary.html">Module</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="nav-bar-cell1-rev">Class</li>
<li><a href="class-use/ExtendedOperatingSystemMXBeanImpl.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../../index-files/index-1.html">Index</a></li>
<li><a href="../../../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="sub-nav">
<div>
<ul class="sub-nav-list">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method.summary">Method</a></li>
</ul>
<ul class="sub-nav-list">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method.detail">Method</a></li>
</ul>
</div>
<div class="nav-list-search"><label for="search">SEARCH:</label>
<input type="text" id="search" value="search" disabled="disabled">
<input type="reset" id="reset" value="reset" disabled="disabled">
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip.navbar.top">
<!--   -->
</span></nav>
</header>
<div class="flex-content">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="sub-title"><span class="module-label-in-type">Module</span>&nbsp;<a href="../../../../../module-summary.html">jdk.management</a></div>
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">com.ibm.lang.management.internal</a></div>
<h1 title="Class ExtendedOperatingSystemMXBeanImpl" class="title">Class ExtendedOperatingSystemMXBeanImpl</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link" target="_blank">java.lang.Object</a>
<div class="inheritance">com.ibm.java.lang.management.internal.OperatingSystemMXBeanImpl
<div class="inheritance">com.ibm.lang.management.internal.ExtendedOperatingSystemMXBeanImpl</div>
</div>
</div>
<section class="description">
<dl class="notes">
<dt>All Implemented Interfaces:</dt>
<dd><code><a href="../OperatingSystemMXBean.html" title="interface in com.ibm.lang.management">OperatingSystemMXBean</a></code>, <code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/jdk.management/com/sun/management/OperatingSystemMXBean.html" title="class or interface in com.sun.management" class="external-link" target="_blank">OperatingSystemMXBean</a></code>, <code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/java/lang/management/OperatingSystemMXBean.html" title="class or interface in java.lang.management" class="external-link" target="_blank">OperatingSystemMXBean</a></code>, <code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/java/lang/management/PlatformManagedObject.html" title="class or interface in java.lang.management" class="external-link" target="_blank">PlatformManagedObject</a></code>, <code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/NotificationBroadcaster.html" title="class or interface in javax.management" class="external-link" target="_blank">NotificationBroadcaster</a></code>, <code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/NotificationEmitter.html" title="class or interface in javax.management" class="external-link" target="_blank">NotificationEmitter</a></code></dd>
</dl>
<dl class="notes">
<dt>Direct Known Subclasses:</dt>
<dd><code><a href="UnixExtendedOperatingSystem.html" title="class in com.ibm.lang.management.internal">UnixExtendedOperatingSystem</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public class </span><span class="element-name type-name-label">ExtendedOperatingSystemMXBeanImpl</span>
<span class="extends-implements">extends com.ibm.java.lang.management.internal.OperatingSystemMXBeanImpl
implements <a href="../OperatingSystemMXBean.html" title="interface in com.ibm.lang.management">OperatingSystemMXBean</a></span></div>
<div class="block">Runtime type for <a href="../OperatingSystemMXBean.html" title="interface in com.ibm.lang.management"><code>OperatingSystemMXBean</code></a>.</div>
<dl class="notes">
<dt>Since:</dt>
<dd>1.7.1</dd>
</dl>
</section>
<section class="summary">
<ul class="summary-list">
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method.summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab1" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab1', 3)" class="table-tab">Static Methods</button><button id="method-summary-table-tab2" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab2', 3)" class="table-tab">Instance Methods</button><button id="method-summary-table-tab4" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab4', 3)" class="table-tab">Concrete Methods</button><button id="method-summary-table-tab6" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab6', 3)" class="table-tab">Deprecated Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code>void</code></div>
<div class="col-second even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#addNotificationListener(javax.management.NotificationListener,javax.management.NotificationFilter,java.lang.Object)">addNotificationListener</a></span>&#8203;(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/NotificationListener.html" title="class or interface in javax.management" class="external-link" target="_blank">NotificationListener</a>&nbsp;listener,
 <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/NotificationFilter.html" title="class or interface in javax.management" class="external-link" target="_blank">NotificationFilter</a>&nbsp;filter,
 <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link" target="_blank">Object</a>&nbsp;handback)</code></div>
<div class="col-last even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Adds a listener to this MBean.</div>
</div>
<div class="col-first odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code>long</code></div>
<div class="col-second odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#getCommittedVirtualMemorySize()">getCommittedVirtualMemorySize</a></span>()</code></div>
<div class="col-last odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Returns the amount of virtual memory used by the process in bytes.</div>
</div>
<div class="col-first even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code>double</code></div>
<div class="col-second even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#getCpuLoad()">getCpuLoad</a></span>()</code></div>
<div class="col-last even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Returns the "recent cpu usage" for the operating environment.</div>
</div>
<div class="col-first odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code>long</code></div>
<div class="col-second odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#getFreeMemorySize()">getFreeMemorySize</a></span>()</code></div>
<div class="col-last odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Returns the amount of free memory in bytes.</div>
</div>
<div class="col-first even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code>long</code></div>
<div class="col-second even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#getFreePhysicalMemorySize()">getFreePhysicalMemorySize</a></span>()</code></div>
<div class="col-last even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Returns the amount of physical memory that is available on the system in bytes.</div>
</div>
<div class="col-first odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code>long</code></div>
<div class="col-second odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#getFreeSwapSpaceSize()">getFreeSwapSpaceSize</a></span>()</code></div>
<div class="col-last odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Returns the amount of free swap space in bytes.</div>
</div>
<div class="col-first even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link" target="_blank">String</a></code></div>
<div class="col-second even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#getHardwareModel()">getHardwareModel</a></span>()</code></div>
<div class="col-last even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Retrieve hardware model</div>
</div>
<div class="col-first odd-row-color method-summary-table-tab1 method-summary-table-tab4 method-summary-table"><code>static <a href="ExtendedOperatingSystemMXBeanImpl.html" title="class in com.ibm.lang.management.internal">ExtendedOperatingSystemMXBeanImpl</a></code></div>
<div class="col-second odd-row-color method-summary-table-tab1 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#getInstance()">getInstance</a></span>()</code></div>
<div class="col-last odd-row-color method-summary-table-tab1 method-summary-table-tab4 method-summary-table">
<div class="block">Singleton accessor method.</div>
</div>
<div class="col-first even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/MBeanNotificationInfo.html" title="class or interface in javax.management" class="external-link" target="_blank">MBeanNotificationInfo</a>[]</code></div>
<div class="col-second even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#getNotificationInfo()">getNotificationInfo</a></span>()</code></div>
<div class="col-last even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Returns an array indicating, for each notification this
 MBean may send, the name of the Java class of the notification
 and the notification type.</div>
</div>
<div class="col-first odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code>double</code></div>
<div class="col-second odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#getProcessCpuLoad()">getProcessCpuLoad</a></span>()</code></div>
<div class="col-last odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Returns the "recent cpu usage" for the Java Virtual Machine process.</div>
</div>
<div class="col-first even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code>long</code></div>
<div class="col-second even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#getProcessCpuTime()">getProcessCpuTime</a></span>()</code></div>
<div class="col-last even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Returns total amount of time the process has been scheduled or
 executed so far in both kernel and user modes.</div>
</div>
<div class="col-first odd-row-color method-summary-table-tab2 method-summary-table-tab6 method-summary-table-tab4 method-summary-table"><code>long</code></div>
<div class="col-second odd-row-color method-summary-table-tab2 method-summary-table-tab6 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#getProcessCpuTimeByNS()">getProcessCpuTimeByNS</a></span>()</code></div>
<div class="col-last odd-row-color method-summary-table-tab2 method-summary-table-tab6 method-summary-table-tab4 method-summary-table">
<div class="block"><span class="deprecated-label">Deprecated, for removal: This API element is subject to removal in a future version.</span></div>
</div>
<div class="col-first even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code>int</code></div>
<div class="col-second even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#getProcessingCapacity()">getProcessingCapacity</a></span>()</code></div>
<div class="col-last even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Returns the collective capacity of the virtual processors in
 the partition the VM is running in.</div>
</div>
<div class="col-first odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code>long</code></div>
<div class="col-second odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#getProcessPhysicalMemorySize()">getProcessPhysicalMemorySize</a></span>()</code></div>
<div class="col-last odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Returns the amount of physical memory being used by the process
 in bytes.</div>
</div>
<div class="col-first even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code>long</code></div>
<div class="col-second even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#getProcessPrivateMemorySize()">getProcessPrivateMemorySize</a></span>()</code></div>
<div class="col-last even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Returns the amount of private memory used by the process in bytes.</div>
</div>
<div class="col-first odd-row-color method-summary-table-tab2 method-summary-table-tab6 method-summary-table-tab4 method-summary-table"><code>long</code></div>
<div class="col-second odd-row-color method-summary-table-tab2 method-summary-table-tab6 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#getProcessVirtualMemorySize()">getProcessVirtualMemorySize</a></span>()</code></div>
<div class="col-last odd-row-color method-summary-table-tab2 method-summary-table-tab6 method-summary-table-tab4 method-summary-table">
<div class="block"><span class="deprecated-label">Deprecated, for removal: This API element is subject to removal in a future version.</span></div>
</div>
<div class="col-first even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code>double</code></div>
<div class="col-second even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#getSystemCpuLoad()">getSystemCpuLoad</a></span>()</code></div>
<div class="col-last even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Returns the "recent cpu usage" for the whole system.</div>
</div>
<div class="col-first odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code>long</code></div>
<div class="col-second odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#getTotalMemorySize()">getTotalMemorySize</a></span>()</code></div>
<div class="col-last odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Returns the total amount of memory in bytes.</div>
</div>
<div class="col-first even-row-color method-summary-table-tab2 method-summary-table-tab6 method-summary-table-tab4 method-summary-table"><code>long</code></div>
<div class="col-second even-row-color method-summary-table-tab2 method-summary-table-tab6 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#getTotalPhysicalMemory()">getTotalPhysicalMemory</a></span>()</code></div>
<div class="col-last even-row-color method-summary-table-tab2 method-summary-table-tab6 method-summary-table-tab4 method-summary-table">
<div class="block"><span class="deprecated-label">Deprecated, for removal: This API element is subject to removal in a future version.</span></div>
</div>
<div class="col-first odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code>long</code></div>
<div class="col-second odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#getTotalPhysicalMemorySize()">getTotalPhysicalMemorySize</a></span>()</code></div>
<div class="col-last odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Returns the total available physical memory on the system in bytes.</div>
</div>
<div class="col-first even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code>long</code></div>
<div class="col-second even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#getTotalSwapSpaceSize()">getTotalSwapSpaceSize</a></span>()</code></div>
<div class="col-last even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Returns the total amount of swap space in bytes.</div>
</div>
<div class="col-first odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#isHardwareEmulated()">isHardwareEmulated</a></span>()</code></div>
<div class="col-last odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Identify whether the underlying hardware is being emulated</div>
</div>
<div class="col-first even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#isProcessRunning(long)">isProcessRunning</a></span>&#8203;(long&nbsp;pid)</code></div>
<div class="col-last even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Indicates if the specified process is running</div>
</div>
<div class="col-first odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#removeNotificationListener(javax.management.NotificationListener)">removeNotificationListener</a></span>&#8203;(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/NotificationListener.html" title="class or interface in javax.management" class="external-link" target="_blank">NotificationListener</a>&nbsp;listener)</code></div>
<div class="col-last odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Removes a listener from this MBean.</div>
</div>
<div class="col-first even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code>void</code></div>
<div class="col-second even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#removeNotificationListener(javax.management.NotificationListener,javax.management.NotificationFilter,java.lang.Object)">removeNotificationListener</a></span>&#8203;(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/NotificationListener.html" title="class or interface in javax.management" class="external-link" target="_blank">NotificationListener</a>&nbsp;listener,
 <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/NotificationFilter.html" title="class or interface in javax.management" class="external-link" target="_blank">NotificationFilter</a>&nbsp;filter,
 <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link" target="_blank">Object</a>&nbsp;handback)</code></div>
<div class="col-last even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Removes a listener from this MBean.</div>
</div>
<div class="col-first odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><a href="../MemoryUsage.html" title="class in com.ibm.lang.management">MemoryUsage</a></code></div>
<div class="col-second odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#retrieveMemoryUsage()">retrieveMemoryUsage</a></span>()</code></div>
<div class="col-last odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Instantiates and returns an instance of <a href="../MemoryUsage.html" title="class in com.ibm.lang.management"><code>MemoryUsage</code></a> object
 that represents the current snapshot of Memory usage statistics.</div>
</div>
<div class="col-first even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><a href="../MemoryUsage.html" title="class in com.ibm.lang.management">MemoryUsage</a></code></div>
<div class="col-second even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#retrieveMemoryUsage(com.ibm.lang.management.MemoryUsage)">retrieveMemoryUsage</a></span>&#8203;(<a href="../MemoryUsage.html" title="class in com.ibm.lang.management">MemoryUsage</a>&nbsp;memoryUsageObj)</code></div>
<div class="col-last even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Returns an updated <a href="../MemoryUsage.html" title="class in com.ibm.lang.management"><code>MemoryUsage</code></a> object that represents the
 current snapshot of Memory usage statistics.</div>
</div>
<div class="col-first odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><a href="../ProcessorUsage.html" title="class in com.ibm.lang.management">ProcessorUsage</a>[]</code></div>
<div class="col-second odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#retrieveProcessorUsage()">retrieveProcessorUsage</a></span>()</code></div>
<div class="col-last odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Instantiates and returns an array of <a href="../ProcessorUsage.html" title="class in com.ibm.lang.management"><code>ProcessorUsage</code></a> objects
 that represent the current snapshot of individual Processor usage times.</div>
</div>
<div class="col-first even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><a href="../ProcessorUsage.html" title="class in com.ibm.lang.management">ProcessorUsage</a>[]</code></div>
<div class="col-second even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#retrieveProcessorUsage(com.ibm.lang.management.ProcessorUsage%5B%5D)">retrieveProcessorUsage</a></span>&#8203;(<a href="../ProcessorUsage.html" title="class in com.ibm.lang.management">ProcessorUsage</a>[]&nbsp;procUsageArr)</code></div>
<div class="col-last even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Returns an updated array of <a href="../ProcessorUsage.html" title="class in com.ibm.lang.management"><code>ProcessorUsage</code></a> objects
 that represent the current snapshot of individual Processor usage times.</div>
</div>
<div class="col-first odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><a href="../ProcessorUsage.html" title="class in com.ibm.lang.management">ProcessorUsage</a></code></div>
<div class="col-second odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#retrieveTotalProcessorUsage()">retrieveTotalProcessorUsage</a></span>()</code></div>
<div class="col-last odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Instantiate and return a new <a href="../ProcessorUsage.html" title="class in com.ibm.lang.management"><code>ProcessorUsage</code></a> object that
 represents the current snapshot of Processor usage statistics.</div>
</div>
<div class="col-first even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><a href="../ProcessorUsage.html" title="class in com.ibm.lang.management">ProcessorUsage</a></code></div>
<div class="col-second even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#retrieveTotalProcessorUsage(com.ibm.lang.management.ProcessorUsage)">retrieveTotalProcessorUsage</a></span>&#8203;(<a href="../ProcessorUsage.html" title="class in com.ibm.lang.management">ProcessorUsage</a>&nbsp;procUsageObj)</code></div>
<div class="col-last even-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Returns an updated <a href="../ProcessorUsage.html" title="class in com.ibm.lang.management"><code>ProcessorUsage</code></a> object that represents the
 current snapshot of Processor usage statistics.</div>
</div>
<div class="col-first odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table"><code><span class="member-name-link"><a href="#sendNotification(javax.management.Notification)">sendNotification</a></span>&#8203;(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/Notification.html" title="class or interface in javax.management" class="external-link" target="_blank">Notification</a>&nbsp;notification)</code></div>
<div class="col-last odd-row-color method-summary-table-tab2 method-summary-table-tab4 method-summary-table">
<div class="block">Send notifications to registered listeners.</div>
</div>
</div>
</div>
</div>
<div class="inherited-list">
<h3 id="methods.inherited.from.class.com.ibm.java.lang.management.internal.OperatingSystemMXBeanImpl">Methods declared in class&nbsp;com.ibm.java.lang.management.internal.OperatingSystemMXBeanImpl</h3>
<code>getArch, getAvailableProcessors, getName, getObjectName, getSystemLoadAverage, getVersion</code></div>
<div class="inherited-list">
<h3 id="methods.inherited.from.class.java.lang.Object">Methods declared in class&nbsp;java.lang.<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link" target="_blank">Object</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#clone()" title="class or interface in java.lang" class="external-link" target="_blank">clone</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#equals(java.lang.Object)" title="class or interface in java.lang" class="external-link" target="_blank">equals</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#finalize()" title="class or interface in java.lang" class="external-link" target="_blank">finalize</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#getClass()" title="class or interface in java.lang" class="external-link" target="_blank">getClass</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#hashCode()" title="class or interface in java.lang" class="external-link" target="_blank">hashCode</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#notify()" title="class or interface in java.lang" class="external-link" target="_blank">notify</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#notifyAll()" title="class or interface in java.lang" class="external-link" target="_blank">notifyAll</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#toString()" title="class or interface in java.lang" class="external-link" target="_blank">toString</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#wait()" title="class or interface in java.lang" class="external-link" target="_blank">wait</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#wait(long)" title="class or interface in java.lang" class="external-link" target="_blank">wait</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html#wait(long,int)" title="class or interface in java.lang" class="external-link" target="_blank">wait</a></code></div>
<div class="inherited-list">
<h3 id="methods.inherited.from.class.java.lang.management.OperatingSystemMXBean">Methods declared in interface&nbsp;java.lang.management.<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/java/lang/management/OperatingSystemMXBean.html" title="class or interface in java.lang.management" class="external-link" target="_blank">OperatingSystemMXBean</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/java/lang/management/OperatingSystemMXBean.html#getArch()" title="class or interface in java.lang.management" class="external-link" target="_blank">getArch</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/java/lang/management/OperatingSystemMXBean.html#getAvailableProcessors()" title="class or interface in java.lang.management" class="external-link" target="_blank">getAvailableProcessors</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/java/lang/management/OperatingSystemMXBean.html#getName()" title="class or interface in java.lang.management" class="external-link" target="_blank">getName</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/java/lang/management/OperatingSystemMXBean.html#getSystemLoadAverage()" title="class or interface in java.lang.management" class="external-link" target="_blank">getSystemLoadAverage</a>, <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/java/lang/management/OperatingSystemMXBean.html#getVersion()" title="class or interface in java.lang.management" class="external-link" target="_blank">getVersion</a></code></div>
<div class="inherited-list">
<h3 id="methods.inherited.from.class.java.lang.management.PlatformManagedObject">Methods declared in interface&nbsp;java.lang.management.<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/java/lang/management/PlatformManagedObject.html" title="class or interface in java.lang.management" class="external-link" target="_blank">PlatformManagedObject</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/java/lang/management/PlatformManagedObject.html#getObjectName()" title="class or interface in java.lang.management" class="external-link" target="_blank">getObjectName</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method.detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="getInstance()">
<h3>getInstance</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="ExtendedOperatingSystemMXBeanImpl.html" title="class in com.ibm.lang.management.internal">ExtendedOperatingSystemMXBeanImpl</a></span>&nbsp;<span class="element-name">getInstance</span>()</div>
<div class="block">Singleton accessor method.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the <a href="ExtendedOperatingSystemMXBeanImpl.html" title="class in com.ibm.lang.management.internal"><code>ExtendedOperatingSystemMXBeanImpl</code></a> singleton.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getFreePhysicalMemorySize()">
<h3>getFreePhysicalMemorySize</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">getFreePhysicalMemorySize</span>()</div>
<div class="block">Returns the amount of physical memory that is available on the system in bytes. 
 Returns -1 if the value is unavailable on this platform or in the case of an error.
 <ul>
 <li>This information is not available on the z/OS platform.
 </ul></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../OperatingSystemMXBean.html#getFreePhysicalMemorySize()">getFreePhysicalMemorySize</a></code>&nbsp;in interface&nbsp;<code><a href="../OperatingSystemMXBean.html" title="interface in com.ibm.lang.management">OperatingSystemMXBean</a></code></dd>
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/jdk.management/com/sun/management/OperatingSystemMXBean.html#getFreePhysicalMemorySize()" title="class or interface in com.sun.management" class="external-link" target="_blank">getFreePhysicalMemorySize</a></code>&nbsp;in interface&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/jdk.management/com/sun/management/OperatingSystemMXBean.html" title="class or interface in com.sun.management" class="external-link" target="_blank">OperatingSystemMXBean</a></code></dd>
<dt>Returns:</dt>
<dd>amount of physical memory available in bytes.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getCpuLoad()">
<h3>getCpuLoad</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">getCpuLoad</span>()</div>
<div class="block">Returns the "recent cpu usage" for the operating environment. This value
 is a double in the [0.0,1.0] interval. A value of 0.0 means that all CPUs
 were idle during the recent period of time observed, while a value
 of 1.0 means that all CPUs were actively running 100% of the time
 during the recent period being observed. All values betweens 0.0 and
 1.0 are possible depending of the activities going on.
 If the recent cpu usage is not available, the method returns a
 negative value.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/jdk.management/com/sun/management/OperatingSystemMXBean.html#getCpuLoad()" title="class or interface in com.sun.management" class="external-link" target="_blank">getCpuLoad</a></code>&nbsp;in interface&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/jdk.management/com/sun/management/OperatingSystemMXBean.html" title="class or interface in com.sun.management" class="external-link" target="_blank">OperatingSystemMXBean</a></code></dd>
<dt>Returns:</dt>
<dd>the "recent cpu usage" for the whole operating environment;
 a negative value if not available.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getTotalMemorySize()">
<h3>getTotalMemorySize</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">getTotalMemorySize</span>()</div>
<div class="block">Returns the total amount of memory in bytes.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/jdk.management/com/sun/management/OperatingSystemMXBean.html#getTotalMemorySize()" title="class or interface in com.sun.management" class="external-link" target="_blank">getTotalMemorySize</a></code>&nbsp;in interface&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/jdk.management/com/sun/management/OperatingSystemMXBean.html" title="class or interface in com.sun.management" class="external-link" target="_blank">OperatingSystemMXBean</a></code></dd>
<dt>Returns:</dt>
<dd>the total amount of memory in  bytes.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getFreeMemorySize()">
<h3>getFreeMemorySize</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">getFreeMemorySize</span>()</div>
<div class="block">Returns the amount of free memory in bytes.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/jdk.management/com/sun/management/OperatingSystemMXBean.html#getFreeMemorySize()" title="class or interface in com.sun.management" class="external-link" target="_blank">getFreeMemorySize</a></code>&nbsp;in interface&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/jdk.management/com/sun/management/OperatingSystemMXBean.html" title="class or interface in com.sun.management" class="external-link" target="_blank">OperatingSystemMXBean</a></code></dd>
<dt>Returns:</dt>
<dd>the amount of free memory in bytes.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getFreeSwapSpaceSize()">
<h3>getFreeSwapSpaceSize</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">getFreeSwapSpaceSize</span>()</div>
<div class="block">Returns the amount of free swap space in bytes.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../OperatingSystemMXBean.html#getFreeSwapSpaceSize()">getFreeSwapSpaceSize</a></code>&nbsp;in interface&nbsp;<code><a href="../OperatingSystemMXBean.html" title="interface in com.ibm.lang.management">OperatingSystemMXBean</a></code></dd>
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/jdk.management/com/sun/management/OperatingSystemMXBean.html#getFreeSwapSpaceSize()" title="class or interface in com.sun.management" class="external-link" target="_blank">getFreeSwapSpaceSize</a></code>&nbsp;in interface&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/jdk.management/com/sun/management/OperatingSystemMXBean.html" title="class or interface in com.sun.management" class="external-link" target="_blank">OperatingSystemMXBean</a></code></dd>
<dt>Returns:</dt>
<dd>the amount of free swap space in bytes.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getHardwareModel()">
<h3>getHardwareModel</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link" target="_blank">String</a></span>&nbsp;<span class="element-name">getHardwareModel</span>()
                              throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/UnsupportedOperationException.html" title="class or interface in java.lang" class="external-link" target="_blank">UnsupportedOperationException</a></span></div>
<div class="block">Retrieve hardware model</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../OperatingSystemMXBean.html#getHardwareModel()">getHardwareModel</a></code>&nbsp;in interface&nbsp;<code><a href="../OperatingSystemMXBean.html" title="interface in com.ibm.lang.management">OperatingSystemMXBean</a></code></dd>
<dt>Returns:</dt>
<dd>String containing the hardware model. NULL in case of an error.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/UnsupportedOperationException.html" title="class or interface in java.lang" class="external-link" target="_blank">UnsupportedOperationException</a></code> - if the operation is not implemented on this platform.
 UnsupportedOperationException will also be thrown if the operation is implemented but it
 cannot be performed because the system does not satisfy all the requirements, for example,
 an OS service is not installed.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getProcessCpuLoad()">
<h3>getProcessCpuLoad</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">getProcessCpuLoad</span>()</div>
<div class="block">Returns the "recent cpu usage" for the Java Virtual Machine process.
 This value is a double in the [0.0,1.0] interval. A value of 0.0 means
 that none of the CPUs were running threads from the JVM process during
 the recent period of time observed, while a value of 1.0 means that all
 CPUs were actively running threads from the JVM 100% of the time
 during the recent period of time observed. Threads from the JVM include
 application threads as well as JVM internal threads. All values
 between 0.0 and 1.0 are possible. The first call to the method always 
 returns <a href="../CpuLoadCalculationConstants.html" title="interface in com.ibm.lang.management"><code>CpuLoadCalculationConstants</code></a>.ERROR_VALUE
 (-1.0), which marks the starting point. If the Java Virtual Machine's recent CPU
 usage is not available, the method returns a negative error code from
 <a href="../CpuLoadCalculationConstants.html" title="interface in com.ibm.lang.management"><code>CpuLoadCalculationConstants</code></a>.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../OperatingSystemMXBean.html#getProcessCpuLoad()">getProcessCpuLoad</a></code>&nbsp;in interface&nbsp;<code><a href="../OperatingSystemMXBean.html" title="interface in com.ibm.lang.management">OperatingSystemMXBean</a></code></dd>
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/jdk.management/com/sun/management/OperatingSystemMXBean.html#getProcessCpuLoad()" title="class or interface in com.sun.management" class="external-link" target="_blank">getProcessCpuLoad</a></code>&nbsp;in interface&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/jdk.management/com/sun/management/OperatingSystemMXBean.html" title="class or interface in com.sun.management" class="external-link" target="_blank">OperatingSystemMXBean</a></code></dd>
<dt>Returns:</dt>
<dd>A value between 0 and 1.0, or a negative error code from
         <a href="../CpuLoadCalculationConstants.html" title="interface in com.ibm.lang.management"><code>CpuLoadCalculationConstants</code></a> in case
         of an error. On the first call to the API,
         <a href="../CpuLoadCalculationConstants.html" title="interface in com.ibm.lang.management"><code>CpuLoadCalculationConstants</code></a>.ERROR_VALUE
         (-1.0) shall be returned.</dd>
<dt>See Also:</dt>
<dd><a href="../CpuLoadCalculationConstants.html" title="interface in com.ibm.lang.management"><code>CpuLoadCalculationConstants</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getProcessCpuTime()">
<h3>getProcessCpuTime</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">getProcessCpuTime</span>()</div>
<div class="block">Returns total amount of time the process has been scheduled or
 executed so far in both kernel and user modes. Returns -1 if the
 value is unavailable on this platform or in the case of an error.
 
 Note that as of Java 8 SR5 the returned value is in 1 ns units, unless the system property 
 com.ibm.lang.management.OperatingSystemMXBean.isCpuTime100ns is set to "true".</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../OperatingSystemMXBean.html#getProcessCpuTime()">getProcessCpuTime</a></code>&nbsp;in interface&nbsp;<code><a href="../OperatingSystemMXBean.html" title="interface in com.ibm.lang.management">OperatingSystemMXBean</a></code></dd>
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/jdk.management/com/sun/management/OperatingSystemMXBean.html#getProcessCpuTime()" title="class or interface in com.sun.management" class="external-link" target="_blank">getProcessCpuTime</a></code>&nbsp;in interface&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/jdk.management/com/sun/management/OperatingSystemMXBean.html" title="class or interface in com.sun.management" class="external-link" target="_blank">OperatingSystemMXBean</a></code></dd>
<dt>Returns:</dt>
<dd>process cpu time.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getProcessCpuTimeByNS()">
<h3>getProcessCpuTimeByNS</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link" target="_blank">@Deprecated</a>(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Deprecated.html#forRemoval()" title="class or interface in java.lang" class="external-link" target="_blank">forRemoval</a>=true,
            <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Deprecated.html#since()" title="class or interface in java.lang" class="external-link" target="_blank">since</a>="1.8")
</span><span class="modifiers">public final</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">getProcessCpuTimeByNS</span>()</div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated, for removal: This API element is subject to removal in a future version.</span></div>
<div class="block">Deprecated. Use getProcessCpuTime()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../OperatingSystemMXBean.html#getProcessCpuTimeByNS()">getProcessCpuTimeByNS</a></code>&nbsp;in interface&nbsp;<code><a href="../OperatingSystemMXBean.html" title="interface in com.ibm.lang.management">OperatingSystemMXBean</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getProcessingCapacity()">
<h3>getProcessingCapacity</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">getProcessingCapacity</span>()</div>
<div class="block">Returns the collective capacity of the virtual processors in
 the partition the VM is running in. The value returned is in
 units of 1% of a physical processor's capacity, so a value of
 100 is equal to 1 physical processor. In environments without
 such partitioning support, this call will return
 getAvailableProcessors() * 100.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../OperatingSystemMXBean.html#getProcessingCapacity()">getProcessingCapacity</a></code>&nbsp;in interface&nbsp;<code><a href="../OperatingSystemMXBean.html" title="interface in com.ibm.lang.management">OperatingSystemMXBean</a></code></dd>
<dt>Returns:</dt>
<dd>the collective capacity of the virtual processors available
 to the VM.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getProcessPhysicalMemorySize()">
<h3>getProcessPhysicalMemorySize</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">getProcessPhysicalMemorySize</span>()</div>
<div class="block">Returns the amount of physical memory being used by the process
 in bytes. Returns -1 if the value is unavailable on this platform
 or in the case of an error.
 <ul>
 <li>This information is not available on the AIX and z/OS platforms.
 </ul></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../OperatingSystemMXBean.html#getProcessPhysicalMemorySize()">getProcessPhysicalMemorySize</a></code>&nbsp;in interface&nbsp;<code><a href="../OperatingSystemMXBean.html" title="interface in com.ibm.lang.management">OperatingSystemMXBean</a></code></dd>
<dt>Returns:</dt>
<dd>amount of physical memory being used by the process in bytes.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getProcessPrivateMemorySize()">
<h3>getProcessPrivateMemorySize</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">getProcessPrivateMemorySize</span>()</div>
<div class="block">Returns the amount of private memory used by the process in bytes.
 Returns -1 if the value is unavailable on this platform or in the
 case of an error.
 <ul>
 <li>This information is not available on the z/OS platform.
 </ul></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../OperatingSystemMXBean.html#getProcessPrivateMemorySize()">getProcessPrivateMemorySize</a></code>&nbsp;in interface&nbsp;<code><a href="../OperatingSystemMXBean.html" title="interface in com.ibm.lang.management">OperatingSystemMXBean</a></code></dd>
<dt>Returns:</dt>
<dd>amount of private memory used by the process in bytes.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getCommittedVirtualMemorySize()">
<h3>getCommittedVirtualMemorySize</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">getCommittedVirtualMemorySize</span>()</div>
<div class="block">Returns the amount of virtual memory used by the process in bytes.
 Returns -1 if the value is unavailable on this platform or in the
 case of an error.
 <ul>
 <li>This information is not available on the z/OS platform.
 </ul></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../OperatingSystemMXBean.html#getCommittedVirtualMemorySize()">getCommittedVirtualMemorySize</a></code>&nbsp;in interface&nbsp;<code><a href="../OperatingSystemMXBean.html" title="interface in com.ibm.lang.management">OperatingSystemMXBean</a></code></dd>
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/jdk.management/com/sun/management/OperatingSystemMXBean.html#getCommittedVirtualMemorySize()" title="class or interface in com.sun.management" class="external-link" target="_blank">getCommittedVirtualMemorySize</a></code>&nbsp;in interface&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/jdk.management/com/sun/management/OperatingSystemMXBean.html" title="class or interface in com.sun.management" class="external-link" target="_blank">OperatingSystemMXBean</a></code></dd>
<dt>Returns:</dt>
<dd>amount of virtual memory used by the process in bytes.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getProcessVirtualMemorySize()">
<h3>getProcessVirtualMemorySize</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link" target="_blank">@Deprecated</a>(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Deprecated.html#forRemoval()" title="class or interface in java.lang" class="external-link" target="_blank">forRemoval</a>=true,
            <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Deprecated.html#since()" title="class or interface in java.lang" class="external-link" target="_blank">since</a>="1.8")
</span><span class="modifiers">public final</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">getProcessVirtualMemorySize</span>()</div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated, for removal: This API element is subject to removal in a future version.</span></div>
<div class="block">Deprecated: use getCommittedVirtualMemorySize()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../OperatingSystemMXBean.html#getProcessVirtualMemorySize()">getProcessVirtualMemorySize</a></code>&nbsp;in interface&nbsp;<code><a href="../OperatingSystemMXBean.html" title="interface in com.ibm.lang.management">OperatingSystemMXBean</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getSystemCpuLoad()">
<h3>getSystemCpuLoad</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">getSystemCpuLoad</span>()</div>
<div class="block">Returns the "recent cpu usage" for the whole system. This value is a double in
 the [0.0,1.0] interval. A value of 0.0 means all CPUs were idle in the recent
 period of time observed, while a value of 1.0 means that all CPUs were actively
 running 100% of the time during the recent period of time observed. All values
 between 0.0 and 1.0 are possible. The first call to the method always 
 returns <a href="../CpuLoadCalculationConstants.html" title="interface in com.ibm.lang.management"><code>CpuLoadCalculationConstants</code></a>.ERROR_VALUE
 (-1.0), which marks the starting point. If the Java Virtual Machine's recent CPU
 usage is not available, the method returns a negative error code from
 <a href="../CpuLoadCalculationConstants.html" title="interface in com.ibm.lang.management"><code>CpuLoadCalculationConstants</code></a>.
 <p>getSystemCpuLoad might not return the same value that is reported by operating system
 utilities such as Unix "top" or Windows task manager.</p></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../OperatingSystemMXBean.html#getSystemCpuLoad()">getSystemCpuLoad</a></code>&nbsp;in interface&nbsp;<code><a href="../OperatingSystemMXBean.html" title="interface in com.ibm.lang.management">OperatingSystemMXBean</a></code></dd>
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/jdk.management/com/sun/management/OperatingSystemMXBean.html#getSystemCpuLoad()" title="class or interface in com.sun.management" class="external-link" target="_blank">getSystemCpuLoad</a></code>&nbsp;in interface&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/jdk.management/com/sun/management/OperatingSystemMXBean.html" title="class or interface in com.sun.management" class="external-link" target="_blank">OperatingSystemMXBean</a></code></dd>
<dt>Returns:</dt>
<dd>A value between 0 and 1.0, or a negative error code from
         <a href="../CpuLoadCalculationConstants.html" title="interface in com.ibm.lang.management"><code>CpuLoadCalculationConstants</code></a> in case
         of an error. On the first call to the API,
         <a href="../CpuLoadCalculationConstants.html" title="interface in com.ibm.lang.management"><code>CpuLoadCalculationConstants</code></a>.ERROR_VALUE
         (-1.0) shall be returned.
 <ul>
 <li>Because this information is not available on z/OS, the call returns
 <a href="../CpuLoadCalculationConstants.html" title="interface in com.ibm.lang.management"><code>CpuLoadCalculationConstants</code></a>.UNSUPPORTED_VALUE
 (-3.0).
 </ul></dd>
<dt>See Also:</dt>
<dd><a href="../CpuLoadCalculationConstants.html" title="interface in com.ibm.lang.management"><code>CpuLoadCalculationConstants</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getTotalPhysicalMemorySize()">
<h3>getTotalPhysicalMemorySize</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">getTotalPhysicalMemorySize</span>()</div>
<div class="block">Returns the total available physical memory on the system in bytes.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../OperatingSystemMXBean.html#getTotalPhysicalMemorySize()">getTotalPhysicalMemorySize</a></code>&nbsp;in interface&nbsp;<code><a href="../OperatingSystemMXBean.html" title="interface in com.ibm.lang.management">OperatingSystemMXBean</a></code></dd>
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/jdk.management/com/sun/management/OperatingSystemMXBean.html#getTotalPhysicalMemorySize()" title="class or interface in com.sun.management" class="external-link" target="_blank">getTotalPhysicalMemorySize</a></code>&nbsp;in interface&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/jdk.management/com/sun/management/OperatingSystemMXBean.html" title="class or interface in com.sun.management" class="external-link" target="_blank">OperatingSystemMXBean</a></code></dd>
<dt>Returns:</dt>
<dd>the total available physical memory on the system in bytes.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getTotalPhysicalMemory()">
<h3>getTotalPhysicalMemory</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link" target="_blank">@Deprecated</a>(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Deprecated.html#forRemoval()" title="class or interface in java.lang" class="external-link" target="_blank">forRemoval</a>=true,
            <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Deprecated.html#since()" title="class or interface in java.lang" class="external-link" target="_blank">since</a>="1.8")
</span><span class="modifiers">public final</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">getTotalPhysicalMemory</span>()</div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated, for removal: This API element is subject to removal in a future version.</span></div>
<div class="block">Deprecated: use getTotalPhysicalMemorySize()</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../OperatingSystemMXBean.html#getTotalPhysicalMemory()">getTotalPhysicalMemory</a></code>&nbsp;in interface&nbsp;<code><a href="../OperatingSystemMXBean.html" title="interface in com.ibm.lang.management">OperatingSystemMXBean</a></code></dd>
<dt>Returns:</dt>
<dd>the total available physical memory on the system in bytes.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getTotalSwapSpaceSize()">
<h3>getTotalSwapSpaceSize</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">getTotalSwapSpaceSize</span>()</div>
<div class="block">Returns the total amount of swap space in bytes.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../OperatingSystemMXBean.html#getTotalSwapSpaceSize()">getTotalSwapSpaceSize</a></code>&nbsp;in interface&nbsp;<code><a href="../OperatingSystemMXBean.html" title="interface in com.ibm.lang.management">OperatingSystemMXBean</a></code></dd>
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/jdk.management/com/sun/management/OperatingSystemMXBean.html#getTotalSwapSpaceSize()" title="class or interface in com.sun.management" class="external-link" target="_blank">getTotalSwapSpaceSize</a></code>&nbsp;in interface&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/jdk.management/com/sun/management/OperatingSystemMXBean.html" title="class or interface in com.sun.management" class="external-link" target="_blank">OperatingSystemMXBean</a></code></dd>
<dt>Returns:</dt>
<dd>the total amount of swap space in bytes.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isHardwareEmulated()">
<h3>isHardwareEmulated</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isHardwareEmulated</span>()
                                 throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/UnsupportedOperationException.html" title="class or interface in java.lang" class="external-link" target="_blank">UnsupportedOperationException</a></span></div>
<div class="block">Identify whether the underlying hardware is being emulated</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../OperatingSystemMXBean.html#isHardwareEmulated()">isHardwareEmulated</a></code>&nbsp;in interface&nbsp;<code><a href="../OperatingSystemMXBean.html" title="interface in com.ibm.lang.management">OperatingSystemMXBean</a></code></dd>
<dt>Returns:</dt>
<dd>True if it is possible to identify that the hardware is being emulated. False otherwise.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/UnsupportedOperationException.html" title="class or interface in java.lang" class="external-link" target="_blank">UnsupportedOperationException</a></code> - if the emulated status cannot be determined</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="retrieveMemoryUsage()">
<h3>retrieveMemoryUsage</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type"><a href="../MemoryUsage.html" title="class in com.ibm.lang.management">MemoryUsage</a></span>&nbsp;<span class="element-name">retrieveMemoryUsage</span>()
                                      throws <span class="exceptions"><a href="../MemoryUsageRetrievalException.html" title="class in com.ibm.lang.management">MemoryUsageRetrievalException</a></span></div>
<div class="block">Instantiates and returns an instance of <a href="../MemoryUsage.html" title="class in com.ibm.lang.management"><code>MemoryUsage</code></a> object
 that represents the current snapshot of Memory usage statistics.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../OperatingSystemMXBean.html#retrieveMemoryUsage()">retrieveMemoryUsage</a></code>&nbsp;in interface&nbsp;<code><a href="../OperatingSystemMXBean.html" title="interface in com.ibm.lang.management">OperatingSystemMXBean</a></code></dd>
<dt>Returns:</dt>
<dd>The new <a href="../MemoryUsage.html" title="class in com.ibm.lang.management"><code>MemoryUsage</code></a> object.</dd>
<dt>Throws:</dt>
<dd><code><a href="../MemoryUsageRetrievalException.html" title="class in com.ibm.lang.management">MemoryUsageRetrievalException</a></code> - if it failed obtaining Memory usage statistics.

 <p>In case of an exception, the handler code might use toString() on the exception code
 to obtain a description of the exception.</p></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="retrieveMemoryUsage(com.ibm.lang.management.MemoryUsage)">
<h3>retrieveMemoryUsage</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type"><a href="../MemoryUsage.html" title="class in com.ibm.lang.management">MemoryUsage</a></span>&nbsp;<span class="element-name">retrieveMemoryUsage</span>&#8203;<span class="parameters">(<a href="../MemoryUsage.html" title="class in com.ibm.lang.management">MemoryUsage</a>&nbsp;memoryUsageObj)</span>
                                      throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/NullPointerException.html" title="class or interface in java.lang" class="external-link" target="_blank">NullPointerException</a>,
<a href="../MemoryUsageRetrievalException.html" title="class in com.ibm.lang.management">MemoryUsageRetrievalException</a></span></div>
<div class="block">Returns an updated <a href="../MemoryUsage.html" title="class in com.ibm.lang.management"><code>MemoryUsage</code></a> object that represents the
 current snapshot of Memory usage statistics.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../OperatingSystemMXBean.html#retrieveMemoryUsage(com.ibm.lang.management.MemoryUsage)">retrieveMemoryUsage</a></code>&nbsp;in interface&nbsp;<code><a href="../OperatingSystemMXBean.html" title="interface in com.ibm.lang.management">OperatingSystemMXBean</a></code></dd>
<dt>Parameters:</dt>
<dd><code>memoryUsageObj</code> - User provided <a href="../MemoryUsage.html" title="class in com.ibm.lang.management"><code>MemoryUsage</code></a> object.</dd>
<dt>Returns:</dt>
<dd>The updated <a href="../MemoryUsage.html" title="class in com.ibm.lang.management"><code>MemoryUsage</code></a> object.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/NullPointerException.html" title="class or interface in java.lang" class="external-link" target="_blank">NullPointerException</a></code> - if a null reference is passed as parameter.</dd>
<dd><code><a href="../MemoryUsageRetrievalException.html" title="class in com.ibm.lang.management">MemoryUsageRetrievalException</a></code> - if it failed obtaining Memory usage statistics.

 <p>In case of an exception, the handler code might use toString() on the exception code
 to obtain a description of the exception.</p></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="retrieveProcessorUsage()">
<h3>retrieveProcessorUsage</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type"><a href="../ProcessorUsage.html" title="class in com.ibm.lang.management">ProcessorUsage</a>[]</span>&nbsp;<span class="element-name">retrieveProcessorUsage</span>()
                                              throws <span class="exceptions"><a href="../ProcessorUsageRetrievalException.html" title="class in com.ibm.lang.management">ProcessorUsageRetrievalException</a></span></div>
<div class="block">Instantiates and returns an array of <a href="../ProcessorUsage.html" title="class in com.ibm.lang.management"><code>ProcessorUsage</code></a> objects
 that represent the current snapshot of individual Processor usage times.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../OperatingSystemMXBean.html#retrieveProcessorUsage()">retrieveProcessorUsage</a></code>&nbsp;in interface&nbsp;<code><a href="../OperatingSystemMXBean.html" title="interface in com.ibm.lang.management">OperatingSystemMXBean</a></code></dd>
<dt>Returns:</dt>
<dd>The new array of <a href="../ProcessorUsage.html" title="class in com.ibm.lang.management"><code>ProcessorUsage</code></a> objects.</dd>
<dt>Throws:</dt>
<dd><code><a href="../ProcessorUsageRetrievalException.html" title="class in com.ibm.lang.management">ProcessorUsageRetrievalException</a></code> - if it failed obtaining Processor usage statistics.

 <p>In case of an exception, the handler code might use toString() on the exception code
 to obtain a description of the exception.</p></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="retrieveProcessorUsage(com.ibm.lang.management.ProcessorUsage[])">
<h3>retrieveProcessorUsage</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type"><a href="../ProcessorUsage.html" title="class in com.ibm.lang.management">ProcessorUsage</a>[]</span>&nbsp;<span class="element-name">retrieveProcessorUsage</span>&#8203;<span class="parameters">(<a href="../ProcessorUsage.html" title="class in com.ibm.lang.management">ProcessorUsage</a>[]&nbsp;procUsageArr)</span>
                                              throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/NullPointerException.html" title="class or interface in java.lang" class="external-link" target="_blank">NullPointerException</a>,
<a href="../ProcessorUsageRetrievalException.html" title="class in com.ibm.lang.management">ProcessorUsageRetrievalException</a>,
<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/IllegalArgumentException.html" title="class or interface in java.lang" class="external-link" target="_blank">IllegalArgumentException</a></span></div>
<div class="block">Returns an updated array of <a href="../ProcessorUsage.html" title="class in com.ibm.lang.management"><code>ProcessorUsage</code></a> objects
 that represent the current snapshot of individual Processor usage times.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../OperatingSystemMXBean.html#retrieveProcessorUsage(com.ibm.lang.management.ProcessorUsage%5B%5D)">retrieveProcessorUsage</a></code>&nbsp;in interface&nbsp;<code><a href="../OperatingSystemMXBean.html" title="interface in com.ibm.lang.management">OperatingSystemMXBean</a></code></dd>
<dt>Parameters:</dt>
<dd><code>procUsageArr</code> - User provided array of <a href="../ProcessorUsage.html" title="class in com.ibm.lang.management"><code>ProcessorUsage</code></a> objects.</dd>
<dt>Returns:</dt>
<dd>The updated array of <a href="../ProcessorUsage.html" title="class in com.ibm.lang.management"><code>ProcessorUsage</code></a> objects.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/NullPointerException.html" title="class or interface in java.lang" class="external-link" target="_blank">NullPointerException</a></code> - if a null reference is passed as parameter.</dd>
<dd><code><a href="../ProcessorUsageRetrievalException.html" title="class in com.ibm.lang.management">ProcessorUsageRetrievalException</a></code> - if it failed obtaining Processor usage statistics.</dd>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/IllegalArgumentException.html" title="class or interface in java.lang" class="external-link" target="_blank">IllegalArgumentException</a></code> - if array provided has insufficient entries and there are more 
                   Processors to report on.

 <p>In case of an exception, the handler code might use toString() on the exception code
 to obtain a description of the exception.</p></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="retrieveTotalProcessorUsage()">
<h3>retrieveTotalProcessorUsage</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type"><a href="../ProcessorUsage.html" title="class in com.ibm.lang.management">ProcessorUsage</a></span>&nbsp;<span class="element-name">retrieveTotalProcessorUsage</span>()
                                                 throws <span class="exceptions"><a href="../ProcessorUsageRetrievalException.html" title="class in com.ibm.lang.management">ProcessorUsageRetrievalException</a></span></div>
<div class="block">Instantiate and return a new <a href="../ProcessorUsage.html" title="class in com.ibm.lang.management"><code>ProcessorUsage</code></a> object that
 represents the current snapshot of Processor usage statistics. The snapshot is the
 aggregate of all Processors that are online at the time of sampling.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../OperatingSystemMXBean.html#retrieveTotalProcessorUsage()">retrieveTotalProcessorUsage</a></code>&nbsp;in interface&nbsp;<code><a href="../OperatingSystemMXBean.html" title="interface in com.ibm.lang.management">OperatingSystemMXBean</a></code></dd>
<dt>Returns:</dt>
<dd>The new <a href="../ProcessorUsage.html" title="class in com.ibm.lang.management"><code>ProcessorUsage</code></a> object.</dd>
<dt>Throws:</dt>
<dd><code><a href="../ProcessorUsageRetrievalException.html" title="class in com.ibm.lang.management">ProcessorUsageRetrievalException</a></code> - if it failed obtaining Processor usage statistics.

 <p>In case of an exception, the handler code might use toString() on the exception code
 to obtain a description of the exception.</p></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="retrieveTotalProcessorUsage(com.ibm.lang.management.ProcessorUsage)">
<h3>retrieveTotalProcessorUsage</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type"><a href="../ProcessorUsage.html" title="class in com.ibm.lang.management">ProcessorUsage</a></span>&nbsp;<span class="element-name">retrieveTotalProcessorUsage</span>&#8203;<span class="parameters">(<a href="../ProcessorUsage.html" title="class in com.ibm.lang.management">ProcessorUsage</a>&nbsp;procUsageObj)</span>
                                                 throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/NullPointerException.html" title="class or interface in java.lang" class="external-link" target="_blank">NullPointerException</a>,
<a href="../ProcessorUsageRetrievalException.html" title="class in com.ibm.lang.management">ProcessorUsageRetrievalException</a></span></div>
<div class="block">Returns an updated <a href="../ProcessorUsage.html" title="class in com.ibm.lang.management"><code>ProcessorUsage</code></a> object that represents the
 current snapshot of Processor usage statistics. The snapshot is the aggregate of all
 Processors that are online at the time of sampling.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../OperatingSystemMXBean.html#retrieveTotalProcessorUsage(com.ibm.lang.management.ProcessorUsage)">retrieveTotalProcessorUsage</a></code>&nbsp;in interface&nbsp;<code><a href="../OperatingSystemMXBean.html" title="interface in com.ibm.lang.management">OperatingSystemMXBean</a></code></dd>
<dt>Parameters:</dt>
<dd><code>procUsageObj</code> - User provided <a href="../ProcessorUsage.html" title="class in com.ibm.lang.management"><code>ProcessorUsage</code></a> object.</dd>
<dt>Returns:</dt>
<dd>The updated <a href="../ProcessorUsage.html" title="class in com.ibm.lang.management"><code>ProcessorUsage</code></a> object.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/NullPointerException.html" title="class or interface in java.lang" class="external-link" target="_blank">NullPointerException</a></code> - if a null reference is passed as parameter.</dd>
<dd><code><a href="../ProcessorUsageRetrievalException.html" title="class in com.ibm.lang.management">ProcessorUsageRetrievalException</a></code> - if it failed obtaining Processor usage statistics.

 <p>In case of an exception, the handler code might use toString() on the exception code
 to obtain a description of the exception.</p></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getNotificationInfo()">
<h3>getNotificationInfo</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/MBeanNotificationInfo.html" title="class or interface in javax.management" class="external-link" target="_blank">MBeanNotificationInfo</a>[]</span>&nbsp;<span class="element-name">getNotificationInfo</span>()</div>
<div class="block"><p>Returns an array indicating, for each notification this
 MBean may send, the name of the Java class of the notification
 and the notification type.</p>

 <p>It is not illegal for the MBean to send notifications not
 described in this array.  However, some clients of the MBean
 server may depend on the array being complete for their correct
 functioning.</p></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/NotificationBroadcaster.html#getNotificationInfo()" title="class or interface in javax.management" class="external-link" target="_blank">getNotificationInfo</a></code>&nbsp;in interface&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/NotificationBroadcaster.html" title="class or interface in javax.management" class="external-link" target="_blank">NotificationBroadcaster</a></code></dd>
<dt>Returns:</dt>
<dd>the array of possible notifications.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isProcessRunning(long)">
<h3>isProcessRunning</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isProcessRunning</span>&#8203;<span class="parameters">(long&nbsp;pid)</span></div>
<div class="block"><span class="descfrm-type-label">Description copied from interface:&nbsp;<code><a href="../OperatingSystemMXBean.html#isProcessRunning(long)">OperatingSystemMXBean</a></code></span></div>
<div class="block">Indicates if the specified process is running</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../OperatingSystemMXBean.html#isProcessRunning(long)">isProcessRunning</a></code>&nbsp;in interface&nbsp;<code><a href="../OperatingSystemMXBean.html" title="interface in com.ibm.lang.management">OperatingSystemMXBean</a></code></dd>
<dt>Parameters:</dt>
<dd><code>pid</code> - Operating system process ID</dd>
<dt>Returns:</dt>
<dd>True if the specified process exists</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="addNotificationListener(javax.management.NotificationListener,javax.management.NotificationFilter,java.lang.Object)">
<h3>addNotificationListener</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">addNotificationListener</span>&#8203;<span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/NotificationListener.html" title="class or interface in javax.management" class="external-link" target="_blank">NotificationListener</a>&nbsp;listener,
 <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/NotificationFilter.html" title="class or interface in javax.management" class="external-link" target="_blank">NotificationFilter</a>&nbsp;filter,
 <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link" target="_blank">Object</a>&nbsp;handback)</span>
                             throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/IllegalArgumentException.html" title="class or interface in java.lang" class="external-link" target="_blank">IllegalArgumentException</a></span></div>
<div class="block">Adds a listener to this MBean.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/NotificationBroadcaster.html#addNotificationListener(javax.management.NotificationListener,javax.management.NotificationFilter,java.lang.Object)" title="class or interface in javax.management" class="external-link" target="_blank">addNotificationListener</a></code>&nbsp;in interface&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/NotificationBroadcaster.html" title="class or interface in javax.management" class="external-link" target="_blank">NotificationBroadcaster</a></code></dd>
<dt>Parameters:</dt>
<dd><code>listener</code> - The listener object which will handle the
 notifications emitted by the broadcaster.</dd>
<dd><code>filter</code> - The filter object. If filter is null, no
 filtering will be performed before handling notifications.</dd>
<dd><code>handback</code> - An opaque object to be sent back to the
 listener when a notification is emitted. This object cannot be
 used by the Notification broadcaster object. It should be
 resent unchanged with the notification to the listener.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/IllegalArgumentException.html" title="class or interface in java.lang" class="external-link" target="_blank">IllegalArgumentException</a></code> - Listener parameter is null.</dd>
<dt>See Also:</dt>
<dd><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/NotificationBroadcaster.html#removeNotificationListener(javax.management.NotificationListener)" title="class or interface in javax.management" class="external-link" target="_blank"><code>NotificationBroadcaster.removeNotificationListener(javax.management.NotificationListener)</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="removeNotificationListener(javax.management.NotificationListener)">
<h3>removeNotificationListener</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">removeNotificationListener</span>&#8203;<span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/NotificationListener.html" title="class or interface in javax.management" class="external-link" target="_blank">NotificationListener</a>&nbsp;listener)</span>
                                      throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/ListenerNotFoundException.html" title="class or interface in javax.management" class="external-link" target="_blank">ListenerNotFoundException</a></span></div>
<div class="block">Removes a listener from this MBean.  If the listener
 has been registered with different handback objects or
 notification filters, all entries corresponding to the listener
 will be removed.</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/NotificationBroadcaster.html#removeNotificationListener(javax.management.NotificationListener)" title="class or interface in javax.management" class="external-link" target="_blank">removeNotificationListener</a></code>&nbsp;in interface&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/NotificationBroadcaster.html" title="class or interface in javax.management" class="external-link" target="_blank">NotificationBroadcaster</a></code></dd>
<dt>Parameters:</dt>
<dd><code>listener</code> - A listener that was previously added to this
 MBean.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/ListenerNotFoundException.html" title="class or interface in javax.management" class="external-link" target="_blank">ListenerNotFoundException</a></code> - The listener is not
 registered with the MBean.</dd>
<dt>See Also:</dt>
<dd><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/NotificationBroadcaster.html#addNotificationListener(javax.management.NotificationListener,javax.management.NotificationFilter,java.lang.Object)" title="class or interface in javax.management" class="external-link" target="_blank"><code>NotificationBroadcaster.addNotificationListener(javax.management.NotificationListener, javax.management.NotificationFilter, java.lang.Object)</code></a>, 
<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/NotificationEmitter.html#removeNotificationListener(javax.management.NotificationListener,javax.management.NotificationFilter,java.lang.Object)" title="class or interface in javax.management" class="external-link" target="_blank"><code>NotificationEmitter.removeNotificationListener(javax.management.NotificationListener, javax.management.NotificationFilter, java.lang.Object)</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="removeNotificationListener(javax.management.NotificationListener,javax.management.NotificationFilter,java.lang.Object)">
<h3>removeNotificationListener</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">removeNotificationListener</span>&#8203;<span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/NotificationListener.html" title="class or interface in javax.management" class="external-link" target="_blank">NotificationListener</a>&nbsp;listener,
 <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/NotificationFilter.html" title="class or interface in javax.management" class="external-link" target="_blank">NotificationFilter</a>&nbsp;filter,
 <a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link" target="_blank">Object</a>&nbsp;handback)</span>
                                      throws <span class="exceptions"><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/ListenerNotFoundException.html" title="class or interface in javax.management" class="external-link" target="_blank">ListenerNotFoundException</a></span></div>
<div class="block"><p>Removes a listener from this MBean.  The MBean must have a
 listener that exactly matches the given <code>listener</code>,
 <code>filter</code>, and <code>handback</code> parameters.  If
 there is more than one such listener, only one is removed.</p>

 <p>The <code>filter</code> and <code>handback</code> parameters
 may be null if and only if they are null in a listener to be
 removed.</p></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/NotificationEmitter.html#removeNotificationListener(javax.management.NotificationListener,javax.management.NotificationFilter,java.lang.Object)" title="class or interface in javax.management" class="external-link" target="_blank">removeNotificationListener</a></code>&nbsp;in interface&nbsp;<code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/NotificationEmitter.html" title="class or interface in javax.management" class="external-link" target="_blank">NotificationEmitter</a></code></dd>
<dt>Parameters:</dt>
<dd><code>listener</code> - A listener that was previously added to this
 MBean.</dd>
<dd><code>filter</code> - The filter that was specified when the listener
 was added.</dd>
<dd><code>handback</code> - The handback that was specified when the listener was
 added.</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/ListenerNotFoundException.html" title="class or interface in javax.management" class="external-link" target="_blank">ListenerNotFoundException</a></code> - The listener is not
 registered with the MBean, or it is not registered with the
 given filter and handback.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="sendNotification(javax.management.Notification)">
<h3>sendNotification</h3>
<div class="member-signature"><span class="modifiers">public final</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">sendNotification</span>&#8203;<span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/16/docs/api/java.management/javax/management/Notification.html" title="class or interface in javax.management" class="external-link" target="_blank">Notification</a>&nbsp;notification)</span></div>
<div class="block">Send notifications to registered listeners.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>notification</code> - a notification to be sent</dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small><a href="https://www.eclipse.org/openj9/" target="_blank">Eclipse OpenJ9 website.</a><br> To raise a bug report or suggest an improvement create an <a href="https://github.com/eclipse-openj9/openj9/issues" target="_blank">Eclipse Openj9 issue.</a><br> Copyright &copy; 1998, 2021, IBM Corp. and others.</small></p>
</footer>
</div>
</div>
</body>
</html>
