AbstractCentralProcessor (Operating System and Hardware Information 2.5.1-java7 API)

java.lang.Object
- oshi.hardware.common.AbstractCentralProcessor

All Implemented Interfaces:

Serializable, CentralProcessor, OshiJsonObject

Direct Known Subclasses:

LinuxCentralProcessor, MacCentralProcessor, WindowsCentralProcessor
```
public abstract class AbstractCentralProcessor
extends Object
implements CentralProcessor
```
A CPU as defined in Linux /proc.

Author:

alessandro[at]perucchi[dot]org, alessio.fachechi[at]gmail[dot]com, widdis[at]gmail[dot]com

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`protected Boolean`	`cpu64`
`protected String`	`cpuFamily`
`protected String`	`cpuIdentifier`
`protected String`	`cpuModel`
`protected String`	`cpuName`
`protected String`	`cpuSerialNumber`
`protected String`	`cpuStepping`
`protected String`	`cpuVendor`
`protected Long`	`cpuVendorFreq`
`protected long[][]`	`curProcTicks`
`protected long[]`	`curTicks`
`protected javax.json.JsonBuilderFactory`	`jsonFactory`
`protected int`	`logicalProcessorCount`
`protected int`	`physicalProcessorCount`
`protected long[][]`	`prevProcTicks`
`protected long[]`	`prevTicks`
`protected long`	`procTickTime`
`protected long`	`tickTime`

Constructor Summary

Constructors
Constructor and Description

AbstractCentralProcessor()
Create a Processor

Constructors
Constructor and Description
`AbstractCentralProcessor()` Create a Processor

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected abstract void`	`calculateProcessorCounts()` Updates logical and physical processor counts
`String`	`getFamily()`
`String`	`getIdentifier()` Identifier, eg.
`int`	`getLogicalProcessorCount()` Get the number of logical CPUs available for processing.
`String`	`getModel()`
`String`	`getName()` Name, eg.
`int`	`getPhysicalProcessorCount()` Get the number of physical CPUs/cores available for processing.
`abstract int`	`getProcessCount()` Get the number of processes currently running
`double[]`	`getProcessorCpuLoadBetweenTicks()` Returns the "recent cpu usage" for all logical processors by counting ticks for the processors from `CentralProcessor.getProcessorCpuLoadTicks()` between successive calls of this method, with a minimum interval slightly less than 1 second.
`abstract long[][]`	`getProcessorCpuLoadTicks()` Get Processor CPU Load tick counters.
`String`	`getStepping()`
`double`	`getSystemCpuLoad()` Returns the "recent cpu usage" for the whole system from `OperatingSystemMXBean.getSystemCpuLoad()` if a user is running the Oracle JVM.
`double`	`getSystemCpuLoadBetweenTicks()` Returns the "recent cpu usage" for the whole system by counting ticks from `CentralProcessor.getSystemCpuLoadTicks()` between successive calls of this method, with a minimum interval slightly less than 1 second.
`abstract long[]`	`getSystemCpuLoadTicks()` Get System-wide CPU Load tick counters.
`abstract long`	`getSystemIOWaitTicks()` Get System IOWait tick counters (if available on that Operating System).
`abstract long[]`	`getSystemIrqTicks()` Get System IRQ tick counters (if available on that Operating System).
`double`	`getSystemLoadAverage()` Returns the system load average for the last minute.
`abstract double[]`	`getSystemLoadAverage(int nelem)` Returns the system load average for the number of elements specified, up to 3, representing 1, 5, and 15 minutes.
`abstract String`	`getSystemSerialNumber()` Get the System/CPU Serial Number, if available.
`abstract long`	`getSystemUptime()` Get the System uptime (time since boot).
`abstract int`	`getThreadCount()` Get the number of threads currently running
`String`	`getVendor()` Processor vendor.
`long`	`getVendorFreq()` Vendor frequency (in Hz), eg.
`protected void`	`initTicks()` Initializes tick arrays
`boolean`	`isCpu64bit()` Is CPU 64bit?
`void`	`setCpu64(boolean value)` Set flag is cpu is 64bit.
`void`	`setFamily(String family)`
`void`	`setIdentifier(String identifier)` Set processor identifier.
`void`	`setModel(String model)`
`void`	`setName(String name)` Set processor name.
`void`	`setStepping(String stepping)`
`void`	`setVendor(String vendor)` Set processor vendor.
`void`	`setVendorFreq(long freq)` Set processor vendor frequency (in Hz).
`javax.json.JsonObject`	`toJSON()` Creates a compact JSON string containing the information for this class
`String`	`toString()`
`protected void`	`updateProcessorTicks()` Updates per-processor tick information.
`protected void`	`updateSystemTicks()` Updates system tick information.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface oshi.hardware.CentralProcessor
getProcess, getProcesses, getProcessId

- Field Detail
  - logicalProcessorCount
```
protected int logicalProcessorCount
```
  - physicalProcessorCount
```
protected int physicalProcessorCount
```
  - tickTime
```
protected long tickTime
```
  - prevTicks
```
protected long[] prevTicks
```
  - curTicks
```
protected long[] curTicks
```
  - procTickTime
```
protected long procTickTime
```
  - prevProcTicks
```
protected long[][] prevProcTicks
```
  - curProcTicks
```
protected long[][] curProcTicks
```
  - cpuVendor
```
protected String cpuVendor
```
  - cpuName
```
protected String cpuName
```
  - cpuSerialNumber
```
protected String cpuSerialNumber
```
  - cpuIdentifier
```
protected String cpuIdentifier
```
  - cpuStepping
```
protected String cpuStepping
```
  - cpuModel
```
protected String cpuModel
```
  - cpuFamily
```
protected String cpuFamily
```
  - cpuVendorFreq
```
protected Long cpuVendorFreq
```
  - cpu64
```
protected Boolean cpu64
```
  - jsonFactory
```
protected javax.json.JsonBuilderFactory jsonFactory
```
- Constructor Detail
  - AbstractCentralProcessor
```
public AbstractCentralProcessor()
```
    Create a Processor
- Method Detail
  - initTicks
```
protected void initTicks()
```
    Initializes tick arrays
  - calculateProcessorCounts
```
protected abstract void calculateProcessorCounts()
```
    Updates logical and physical processor counts
  - getVendor
```
public String getVendor()
```
    Processor vendor.
    
    Specified by:
    
    getVendor in interface CentralProcessor
    
    Returns:
    
    vendor string.
  - setVendor
```
public void setVendor(String vendor)
```
    Set processor vendor.
    
    Specified by:
    
    setVendor in interface CentralProcessor
    
    Parameters:
    
    vendor - Vendor.
  - getName
```
public String getName()
```
    Name, eg. Intel(R) Core(TM)2 Duo CPU T7300 @ 2.00GHz
    
    Specified by:
    
    getName in interface CentralProcessor
    
    Returns:
    
    Processor name.
  - setName
```
public void setName(String name)
```
    Set processor name.
    
    Specified by:
    
    setName in interface CentralProcessor
    
    Parameters:
    
    name - Name.
  - getVendorFreq
```
public long getVendorFreq()
```
    Vendor frequency (in Hz), eg. for processor named Intel(R) Core(TM)2 Duo CPU T7300 @ 2.00GHz the vendor frequency is 2000000000.
    
    Specified by:
    
    getVendorFreq in interface CentralProcessor
    
    Returns:
    
    Processor frequency or -1 if unknown.
  - setVendorFreq
```
public void setVendorFreq(long freq)
```
    Set processor vendor frequency (in Hz).
    
    Specified by:
    
    setVendorFreq in interface CentralProcessor
    
    Parameters:
    
    freq - Frequency.
  - getIdentifier
```
public String getIdentifier()
```
    Identifier, eg. x86 Family 6 Model 15 Stepping 10.
    
    Specified by:
    
    getIdentifier in interface CentralProcessor
    
    Returns:
    
    Processor identifier.
  - setIdentifier
```
public void setIdentifier(String identifier)
```
    Set processor identifier.
    
    Specified by:
    
    setIdentifier in interface CentralProcessor
    
    Parameters:
    
    identifier - Identifier.
  - isCpu64bit
```
public boolean isCpu64bit()
```
    Is CPU 64bit?
    
    Specified by:
    
    isCpu64bit in interface CentralProcessor
    
    Returns:
    
    True if cpu is 64bit.
  - setCpu64
```
public void setCpu64(boolean value)
```
    Set flag is cpu is 64bit.
    
    Specified by:
    
    setCpu64 in interface CentralProcessor
    
    Parameters:
    
    value - True if cpu is 64.
  - getStepping
```
public String getStepping()
```
    Specified by:
    
    getStepping in interface CentralProcessor
    
    Returns:
    
    the _stepping
  - setStepping
```
public void setStepping(String stepping)
```
    Specified by:
    
    setStepping in interface CentralProcessor
    
    Parameters:
    
    stepping - the _stepping to set
  - getModel
```
public String getModel()
```
    Specified by:
    
    getModel in interface CentralProcessor
    
    Returns:
    
    the _model
  - setModel
```
public void setModel(String model)
```
    Specified by:
    
    setModel in interface CentralProcessor
    
    Parameters:
    
    model - the _model to set
  - getFamily
```
public String getFamily()
```
    Specified by:
    
    getFamily in interface CentralProcessor
    
    Returns:
    
    the _family
  - setFamily
```
public void setFamily(String family)
```
    Specified by:
    
    setFamily in interface CentralProcessor
    
    Parameters:
    
    family - the _family to set
  - getSystemCpuLoadBetweenTicks
```
public double getSystemCpuLoadBetweenTicks()
```
    Returns the "recent cpu usage" for the whole system by counting ticks from CentralProcessor.getSystemCpuLoadTicks() between successive calls of this method, with a minimum interval slightly less than 1 second. If less than one second has elapsed since the last call of this method, it will return a calculation based on the tick counts and times of the previous two calls. If at least a second has elapsed, it will return the average CPU load for the interval and update the "last called" times. This method is intended to be used for periodic polling at intervals of 1 second or longer.
    
    Specified by:
    
    getSystemCpuLoadBetweenTicks in interface CentralProcessor
    
    Returns:
    
    CPU load between 0 and 1 (100%)
  - getSystemCpuLoadTicks
```
public abstract long[] getSystemCpuLoadTicks()
```
    Get System-wide CPU Load tick counters. Returns an array with four elements representing clock ticks or milliseconds (platform dependent) spent in User (0), Nice (1), System (2), and Idle (3) states. By measuring the difference between ticks across a time interval, CPU load over that interval may be calculated. The Idle time for this method includes system time spent idle waiting for IO as reported by CentralProcessor.getSystemIOWaitTicks(). The system time includes system time spent servicing Hardware and Software IRQ requests as reported by CentralProcessor.getSystemIrqTicks() as well as executing other virtual hosts (steal) or running a virtual cpu (guest).
    
    Specified by:
    
    getSystemCpuLoadTicks in interface CentralProcessor
    
    Returns:
    
    An array of 4 long values representing time spent in User, Nice(if applicable), System, and Idle states.
  - getSystemIOWaitTicks
```
public abstract long getSystemIOWaitTicks()
```
    Get System IOWait tick counters (if available on that Operating System). Time spent waiting for IO to complete is included in the idle time calculated by CentralProcessor.getSystemCpuLoadTicks() but is provided separately for more detail.
    
    Specified by:
    
    getSystemIOWaitTicks in interface CentralProcessor
    
    Returns:
    
    a long value representing time spent idle waiting for IO to complete.
  - getSystemIrqTicks
```
public abstract long[] getSystemIrqTicks()
```
    Get System IRQ tick counters (if available on that Operating System). Time spent servicing hardware and software (Deferred Procedure Call) interrupts is included in the system time calculated by CentralProcessor.getSystemCpuLoadTicks() but is provided separately for more detail.
    
    Specified by:
    
    getSystemIrqTicks in interface CentralProcessor
    
    Returns:
    
    an array of two long values representing time spent servicing hardware interrupts and software interrupts (DPC)
  - updateSystemTicks
```
protected void updateSystemTicks()
```
    Updates system tick information. Stores in array with four elements representing clock ticks or milliseconds (platform dependent) spent in User (0), Nice (1), System (2), and Idle (3) states. By measuring the difference between ticks across a time interval, CPU load over that interval may be calculated.
  - getSystemCpuLoad
```
public double getSystemCpuLoad()
```
    Returns the "recent cpu usage" for the whole system from OperatingSystemMXBean.getSystemCpuLoad() if a user is running the Oracle JVM. 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 between 0.0 and 1.0 are possible depending of the activities going on in the system. If the system recent cpu usage is not available, the method returns a negative value. Calling this method immediately upon instantiating the CentralProcessor may give unreliable results. If a user is not running the Oracle JVM, this method will default to the behavior and return value of CentralProcessor.getSystemCpuLoadBetweenTicks().
    
    Specified by:
    
    getSystemCpuLoad in interface CentralProcessor
    
    Returns:
    
    the "recent cpu usage" for the whole system; a negative value if not available.
  - getSystemLoadAverage
```
public double getSystemLoadAverage()
```
    Returns the system load average for the last minute. This is equivalent to calling CentralProcessor.getSystemLoadAverage(int) with an argument of 1 and returning the first value, and is retained for compatibility.
    
    Specified by:
    
    getSystemLoadAverage in interface CentralProcessor
    
    Returns:
    
    the system load average; or a negative value if not available.
  - getSystemLoadAverage
```
public abstract double[] getSystemLoadAverage(int nelem)
```
    Returns the system load average for the number of elements specified, up to 3, representing 1, 5, and 15 minutes. The system load average is the sum of the number of runnable entities queued to the available processors and the number of runnable entities running on the available processors averaged over a period of time. The way in which the load average is calculated is operating system specific but is typically a damped time-dependent average. If the load average is not available, a negative value is returned. This method is designed to provide a hint about the system load and may be queried frequently. The load average may be unavailable on some platforms (e.g., Windows) where it is expensive to implement this method.
    
    Specified by:
    
    getSystemLoadAverage in interface CentralProcessor
    
    Parameters:
    
    nelem - Number of elements to return.
    
    Returns:
    
    an array of the system load averages for 1, 5, and 15 minutes with the size of the array specified by nelem; or negative values if not available.
  - getProcessorCpuLoadBetweenTicks
```
public double[] getProcessorCpuLoadBetweenTicks()
```
    Returns the "recent cpu usage" for all logical processors by counting ticks for the processors from CentralProcessor.getProcessorCpuLoadTicks() between successive calls of this method, with a minimum interval slightly less than 1 second. If less than one second has elapsed since the last call of this method, it will return a calculation based on the tick counts and times of the previous two calls. If at least a second has elapsed, it will return the average CPU load for the interval and update the "last called" times. This method is intended to be used for periodic polling (iterating over all processors) at intervals of 1 second or longer.
    
    Specified by:
    
    getProcessorCpuLoadBetweenTicks in interface CentralProcessor
    
    Returns:
    
    array of CPU load between 0 and 1 (100%) for each logical processor
  - getProcessorCpuLoadTicks
```
public abstract long[][] getProcessorCpuLoadTicks()
```
    Get Processor CPU Load tick counters. Returns a two dimensional array, with CentralProcessor.getLogicalProcessorCount() arrays, each containing four elements representing clock ticks or milliseconds (platform dependent) spent in User (0), Nice (1), System (2), and Idle (3) states. By measuring the difference between ticks across a time interval, CPU load over that interval may be calculated. The Idle time for this method includes processor time spent idle waiting for IO as reported by CentralProcessor.getSystemIOWaitTicks(). The system time includes processor time spent servicing Hardware IRQ requests as reported by CentralProcessor.getSystemIrqTicks() as well as Software IRQ requests (softirq), executing other virtual hosts (steal) or running a virtual cpu (guest).
    
    Specified by:
    
    getProcessorCpuLoadTicks in interface CentralProcessor
    
    Returns:
    
    A 2D array of logicalProcessorCount x 4 long values representing time spent in User, Nice(if applicable), System, and Idle states.
  - updateProcessorTicks
```
protected void updateProcessorTicks()
```
    Updates per-processor tick information. Stores in 2D array; an array for each logical processor with four elements representing clock ticks or milliseconds (platform dependent) spent in User (0), Nice (1), System (2), and Idle (3) states. By measuring the difference between ticks across a time interval, CPU load over that interval may be calculated.
  - getSystemUptime
```
public abstract long getSystemUptime()
```
    Get the System uptime (time since boot).
    
    Specified by:
    
    getSystemUptime in interface CentralProcessor
    
    Returns:
    
    Number of seconds since boot.
  - getSystemSerialNumber
```
public abstract String getSystemSerialNumber()
```
    Get the System/CPU Serial Number, if available. On Linux, this requires either root permissions, or installation of the (deprecated) HAL library (lshal command).
    
    Specified by:
    
    getSystemSerialNumber in interface CentralProcessor
    
    Returns:
    
    the System/CPU Serial Number, if available, otherwise returns "unknown"
  - getLogicalProcessorCount
```
public int getLogicalProcessorCount()
```
    Get the number of logical CPUs available for processing.
    
    Specified by:
    
    getLogicalProcessorCount in interface CentralProcessor
    
    Returns:
    
    The number of logical CPUs available.
  - getPhysicalProcessorCount
```
public int getPhysicalProcessorCount()
```
    Get the number of physical CPUs/cores available for processing.
    
    Specified by:
    
    getPhysicalProcessorCount in interface CentralProcessor
    
    Returns:
    
    The number of physical CPUs available.
  - getProcessCount
```
public abstract int getProcessCount()
```
    Get the number of processes currently running
    
    Specified by:
    
    getProcessCount in interface CentralProcessor
    
    Returns:
    
    The number of processes running
  - getThreadCount
```
public abstract int getThreadCount()
```
    Get the number of threads currently running
    
    Specified by:
    
    getThreadCount in interface CentralProcessor
    
    Returns:
    
    The number of threads running
  - toJSON
```
public javax.json.JsonObject toJSON()
```
    Creates a compact JSON string containing the information for this class
    
    Specified by:
    
    toJSON in interface OshiJsonObject
    
    Returns:
    
    a compact JSON string
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class AbstractCentralProcessor

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface oshi.hardware.CentralProcessor

Field Detail

logicalProcessorCount

physicalProcessorCount

tickTime

prevTicks

curTicks

procTickTime

prevProcTicks

curProcTicks

cpuVendor

cpuName

cpuSerialNumber

cpuIdentifier

cpuStepping

cpuModel

cpuFamily

cpuVendorFreq

cpu64

jsonFactory

Constructor Detail

AbstractCentralProcessor

Method Detail

initTicks

calculateProcessorCounts

getVendor

setVendor

getName

setName

getVendorFreq

setVendorFreq

getIdentifier

setIdentifier

isCpu64bit

setCpu64

getStepping

setStepping

getModel

setModel

getFamily

setFamily

getSystemCpuLoadBetweenTicks

getSystemCpuLoadTicks

getSystemIOWaitTicks

getSystemIrqTicks

updateSystemTicks

getSystemCpuLoad

getSystemLoadAverage

getSystemLoadAverage

getProcessorCpuLoadBetweenTicks

getProcessorCpuLoadTicks

updateProcessorTicks

getSystemUptime

getSystemSerialNumber

getLogicalProcessorCount

getPhysicalProcessorCount

getProcessCount

getThreadCount

toJSON

toString