@Exported public abstract class VirtualMachine extends Object
 A VirtualMachine represents a Java virtual machine to which this
 Java virtual machine has attached. The Java virtual machine to which it is
 attached is sometimes called the target virtual machine, or target VM.
 An application (typically a tool such as a managemet console or profiler) uses a
 VirtualMachine to load an agent into the target VM. For example, a profiler tool
 written in the Java Language might attach to a running application and load its
 profiler agent to profile the running application. 
 A VirtualMachine is obtained by invoking the attach method
 with an identifier that identifies the target virtual machine. The identifier is
 implementation-dependent but is typically the process identifier (or pid) in
 environments where each Java virtual machine runs in its own operating system process.
 Alternatively, a VirtualMachine instance is obtained by invoking the
 attach method with a VirtualMachineDescriptor obtained
 from the list of virtual machine descriptors returned by the list method.
 Once a reference to a virtual machine is obtained, the loadAgent,
 loadAgentLibrary, and loadAgentPath
 methods are used to load agents into target virtual machine. The loadAgent method is used to load agents that are written in the Java
 Language and deployed in a JAR file. (See
 java.lang.instrument for a detailed description on how these agents
 are loaded and started). The loadAgentLibrary and
 loadAgentPath methods are used to load agents that
 are deployed either in a dynamic library or statically linked into the VM and make use of the JVM Tools
 Interface. 
 In addition to loading agents a VirtualMachine provides read access to the
 system properties in the target VM.
 This can be useful in some environments where properties such as
 java.home, os.name, or os.arch are
 used to construct the path to agent that will be loaded into the target VM.
 
The following example demonstrates how VirtualMachine may be used:
      // attach to target VM
      VirtualMachine vm = VirtualMachine.attach("2177");
      // start management agent
      Properties props = new Properties();
      props.put("com.sun.management.jmxremote.port", "5000");
      vm.startManagementAgent(props);
      // detach
      vm.detach();
 
  In this example we attach to a Java virtual machine that is identified by
 the process identifier 2177. Then the JMX management agent is
 started in the target process using the supplied arguments. Finally, the
 client detaches from the target VM. 
A VirtualMachine is safe for use by multiple concurrent threads.
| Modifier | Constructor and Description | 
|---|---|
| protected  | VirtualMachine(AttachProvider provider,
              String id)Initializes a new instance of this class. | 
| Modifier and Type | Method and Description | 
|---|---|
| static VirtualMachine | attach(String id)Attaches to a Java virtual machine. | 
| static VirtualMachine | attach(VirtualMachineDescriptor vmd)Attaches to a Java virtual machine. | 
| abstract void | detach()Detach from the virtual machine. | 
| boolean | equals(Object ob)Tests this VirtualMachine for equality with another object. | 
| abstract Properties | getAgentProperties()Returns the current agent properties in the target virtual
 machine. | 
| abstract Properties | getSystemProperties()Returns the current system properties in the target virtual machine. | 
| int | hashCode()Returns a hash-code value for this VirtualMachine. | 
| String | id()Returns the identifier for this Java virtual machine. | 
| static List<VirtualMachineDescriptor> | list()Return a list of Java virtual machines. | 
| void | loadAgent(String agent)Loads an agent. | 
| abstract void | loadAgent(String agent,
         String options)Loads an agent. | 
| void | loadAgentLibrary(String agentLibrary)Loads an agent library. | 
| abstract void | loadAgentLibrary(String agentLibrary,
                String options)Loads an agent library. | 
| void | loadAgentPath(String agentPath)Load a native agent library by full pathname. | 
| abstract void | loadAgentPath(String agentPath,
             String options)Load a native agent library by full pathname. | 
| AttachProvider | provider()Returns the provider that created this virtual machine. | 
| abstract String | startLocalManagementAgent()Starts the local JMX management agent in the target virtual machine. | 
| abstract void | startManagementAgent(Properties agentProperties)Starts the JMX management agent in the target virtual machine. | 
| String | toString()Returns the string representation of the  VirtualMachine. | 
protected VirtualMachine(AttachProvider provider, String id)
provider - The attach provider creating this class.id - The abstract identifier that identifies the Java virtual machine.NullPointerException - If provider or id is null.public static List<VirtualMachineDescriptor> list()
 This method returns a list of Java VirtualMachineDescriptor elements.
 The list is an aggregation of the virtual machine
 descriptor lists obtained by invoking the listVirtualMachines method of all installed
 attach providers.
 If there are no Java virtual machines known to any provider
 then an empty list is returned.
public static VirtualMachine attach(String id) throws AttachNotSupportedException, IOException
 This method obtains the list of attach providers by invoking the
 AttachProvider.providers() method. It then iterates overs the list
 and invokes each provider's attachVirtualMachine method in turn. If a provider successfully
 attaches then the iteration terminates, and the VirtualMachine created
 by the provider that successfully attached is returned by this method.
 If the attachVirtualMachine method of all providers throws
 AttachNotSupportedException
 then this method also throws AttachNotSupportedException.
 This means that AttachNotSupportedException is thrown when
 the identifier provided to this method is invalid, or the identifier
 corresponds to a Java virtual machine that does not exist, or none
 of the providers can attach to it. This exception is also thrown if
 AttachProvider.providers() returns an empty list. 
id - The abstract identifier that identifies the Java virtual machine.SecurityException - If a security manager has been installed and it denies
          AttachPermission
          ("attachVirtualMachine"), or another permission
          required by the implementation.AttachNotSupportedException - If the attachVirtualmachine method of all installed
          providers throws AttachNotSupportedException, or
          there aren't any providers installed.IOException - If an I/O error occursNullPointerException - If id is null.public static VirtualMachine attach(VirtualMachineDescriptor vmd) throws AttachNotSupportedException, IOException
 This method first invokes the provider() method
 of the given virtual machine descriptor to obtain the attach provider. It
 then invokes the attach provider's attachVirtualMachine to attach to the target VM.
vmd - The virtual machine descriptor.SecurityException - If a security manager has been installed and it denies
          AttachPermission
          ("attachVirtualMachine"), or another permission
          required by the implementation.AttachNotSupportedException - If the attach provider's attachVirtualmachine
          throws AttachNotSupportedException.IOException - If an I/O error occursNullPointerException - If vmd is null.public abstract void detach()
                     throws IOException
 After detaching from the virtual machine, any further attempt to invoke
 operations on that virtual machine will cause an IOException to be thrown. If an operation (such as loadAgent for example) is in progress when this method is invoked then
 the behaviour is implementation dependent. In other words, it is
 implementation specific if the operation completes or throws
 IOException.
 
If already detached from the virtual machine then invoking this method has no effect.
IOException - If an I/O error occurspublic final AttachProvider provider()
public final String id()
public abstract void loadAgentLibrary(String agentLibrary, String options) throws AgentLoadException, AgentInitializationException, IOException
 A JVM
 TI client is called an agent. It is developed in a native language.
 A JVM TI agent is deployed in a platform specific manner but it is typically the
 platform equivalent of a dynamic library. Alternatively, it may be statically linked into the VM.
 This method causes the given agent library to be loaded into the target
 VM (if not already loaded or if not statically linked into the VM).
 It then causes the target VM to invoke the Agent_OnAttach function
 or, for a statically linked agent named 'L', the Agent_OnAttach_L function
 as specified in the
  JVM Tools
 Interface specification. Note that the Agent_OnAttach[_L]
 function is invoked even if the agent library was loaded prior to invoking
 this method.
 
 The agent library provided is the name of the agent library. It is interpreted
 in the target virtual machine in an implementation-dependent manner. Typically an
 implementation will expand the library name into an operating system specific file
 name. For example, on UNIX systems, the name L might be expanded to
 libL.so, and located using the search path specified by the
 LD_LIBRARY_PATH environment variable. If the agent named 'L' is
 statically linked into the VM then the VM must export a function named
 Agent_OnAttach_L.
 If the Agent_OnAttach[_L] function in the agent library returns
 an error then an AgentInitializationException is
 thrown. The return value from the Agent_OnAttach[_L] can then be
 obtained by invoking the returnValue
 method on the exception. 
agentLibrary - The name of the agent library.options - The options to provide to the Agent_OnAttach[_L]
          function (can be null).AgentLoadException - If the agent library does not exist, the agent library is not
          statically linked with the VM, or the agent library cannot be
          loaded for another reason.AgentInitializationException - If the Agent_OnAttach[_L] function returns an error.IOException - If an I/O error occursNullPointerException - If agentLibrary is null.AgentInitializationException.returnValue()public void loadAgentLibrary(String agentLibrary) throws AgentLoadException, AgentInitializationException, IOException
This convenience method works as if by invoking:
 loadAgentLibrary(agentLibrary, null);
 agentLibrary - The name of the agent library.AgentLoadException - If the agent library does not exist, the agent library is not
          statically linked with the VM, or the agent library cannot be
          loaded for another reason.AgentInitializationException - If the Agent_OnAttach[_L] function returns an error.IOException - If an I/O error occursNullPointerException - If agentLibrary is null.public abstract void loadAgentPath(String agentPath, String options) throws AgentLoadException, AgentInitializationException, IOException
 A JVM
 TI client is called an agent. It is developed in a native language.
 A JVM TI agent is deployed in a platform specific manner but it is typically the
 platform equivalent of a dynamic library. Alternatively, the native
 library specified by the agentPath parameter may be statically
 linked with the VM. The parsing of the agentPath parameter into
 a statically linked library name is done in a platform
 specific manner in the VM. For example, in UNIX, an agentPath parameter
 of /a/b/libL.so would name a library 'L'.
 See the JVM TI Specification for more details.
 This method causes the given agent library to be loaded into the target
 VM (if not already loaded or if not statically linked into the VM).
 It then causes the target VM to invoke the Agent_OnAttach
 function or, for a statically linked agent named 'L', the
 Agent_OnAttach_L function as specified in the
  JVM Tools
 Interface specification.
 Note that the Agent_OnAttach[_L]
 function is invoked even if the agent library was loaded prior to invoking
 this method.
 
 The agent library provided is the absolute path from which to load the
 agent library. Unlike loadAgentLibrary, the library name
 is not expanded in the target virtual machine. 
 If the Agent_OnAttach[_L] function in the agent library returns
 an error then an AgentInitializationException is
 thrown. The return value from the Agent_OnAttach[_L] can then be
 obtained by invoking the returnValue
 method on the exception. 
agentPath - The full path of the agent library.options - The options to provide to the Agent_OnAttach[_L]
          function (can be null).AgentLoadException - If the agent library does not exist, the agent library is not
          statically linked with the VM, or the agent library cannot be
          loaded for another reason.AgentInitializationException - If the Agent_OnAttach[_L] function returns an error.IOException - If an I/O error occursNullPointerException - If agentPath is null.AgentInitializationException.returnValue()public void loadAgentPath(String agentPath) throws AgentLoadException, AgentInitializationException, IOException
This convenience method works as if by invoking:
 loadAgentPath(agentLibrary, null);
 agentPath - The full path to the agent library.AgentLoadException - If the agent library does not exist, the agent library is not
          statically linked with the VM, or the agent library cannot be
          loaded for another reason.AgentInitializationException - If the Agent_OnAttach[_L] function returns an error.IOException - If an I/O error occursNullPointerException - If agentPath is null.public abstract void loadAgent(String agent, String options) throws AgentLoadException, AgentInitializationException, IOException
 The agent provided to this method is a path name to a JAR file on the file
 system of the target virtual machine. This path is passed to the target virtual
 machine where it is interpreted. The target virtual machine attempts to start
 the agent as specified by the java.lang.instrument specification.
 That is, the specified JAR file is added to the system class path (of the target
 virtual machine), and the agentmain method of the agent class, specified
 by the Agent-Class attribute in the JAR manifest, is invoked. This
 method completes when the agentmain method completes.
agent - Path to the JAR file containing the agent.options - The options to provide to the agent's agentmain
          method (can be null).AgentLoadException - If the agent does not exist, or cannot be started in the manner
          specified in the java.lang.instrument specification.AgentInitializationException - If the agentmain throws an exceptionIOException - If an I/O error occursNullPointerException - If agent is null.public void loadAgent(String agent) throws AgentLoadException, AgentInitializationException, IOException
This convenience method works as if by invoking:
 loadAgent(agent, null);
 agent - Path to the JAR file containing the agent.AgentLoadException - If the agent does not exist, or cannot be started in the manner
          specified in the java.lang.instrument specification.AgentInitializationException - If the agentmain throws an exceptionIOException - If an I/O error occursNullPointerException - If agent is null.public abstract Properties getSystemProperties() throws IOException
 This method returns the system properties in the target virtual
 machine. Properties whose key or value is not a String are
 omitted. The method is approximately equivalent to the invocation of the
 method System.getProperties
 in the target virtual machine except that properties with a key or
 value that is not a String are not included.
 
 This method is typically used to decide which agent to load into
 the target virtual machine with loadAgent, or
 loadAgentLibrary. For example, the
 java.home or user.dir properties might be
 use to create the path to the agent library or JAR file.
AttachOperationFailedException - If the target virtual machine is unable to complete the
          attach operation. A more specific error message will be
          given by Throwable.getMessage().IOException - If an I/O error occurs, a communication error for example,
          that cannot be identified as an error to indicate that the
          operation failed in the target VM.System.getProperties(), 
loadAgentLibrary(java.lang.String, java.lang.String), 
loadAgent(java.lang.String, java.lang.String)public abstract Properties getAgentProperties() throws IOException
The target virtual machine can maintain a list of properties on behalf of agents. The manner in which this is done, the names of the properties, and the types of values that are allowed, is implementation specific. Agent properties are typically used to store communication end-points and other agent configuration details. For example, a debugger agent might create an agent property for its transport address.
This method returns the agent properties whose key and value is a String. Properties whose key or value is not a String are omitted. If there are no agent properties maintained in the target virtual machine then an empty property list is returned.
AttachOperationFailedException - If the target virtual machine is unable to complete the
               attach operation. A more specific error message will be
               given by Throwable.getMessage().IOException - If an I/O error occurs, a communication error for example,
               that cannot be identified as an error to indicate that the
               operation failed in the target VM.public abstract void startManagementAgent(Properties agentProperties) throws IOException
 The configuration properties are the same as those specified on
 the command line when starting the JMX management agent. In the same
 way as on the command line, you need to specify at least the
 com.sun.management.jmxremote.port property.
 
See the online documentation for Monitoring and Management Using JMX Technology for further details.
agentProperties - A Properties object containing the configuration properties
          for the agent.AttachOperationFailedException - If the target virtual machine is unable to complete the
          attach operation. A more specific error message will be
          given by Throwable.getMessage().IOException - If an I/O error occurs, a communication error for example,
          that cannot be identified as an error to indicate that the
          operation failed in the target VM.IllegalArgumentException - If keys or values in agentProperties are invalid.NullPointerException - If agentProperties is null.public abstract String startLocalManagementAgent() throws IOException
See the online documentation for Monitoring and Management Using JMX Technology for further details.
JMXServiceURL
          constructor.AttachOperationFailedException - If the target virtual machine is unable to complete the
          attach operation. A more specific error message will be
          given by Throwable.getMessage().IOException - If an I/O error occurs, a communication error for example,
          that cannot be identified as an error to indicate that the
          operation failed in the target VM.public int hashCode()
Object.hashCode method.hashCode in class ObjectObject.equals(java.lang.Object), 
System.identityHashCode(java.lang.Object)public boolean equals(Object ob)
 If the given object is not a VirtualMachine then this
 method returns false. For two VirtualMachines to
 be considered equal requires that they both reference the same
 provider, and their identifiers are equal. 
 This method satisfies the general contract of the Object.equals method. 
equals in class Objectob - The object to which this object is to be comparedObject.hashCode(), 
HashMap
 Copyright © 2005, 2025, Oracle and/or its affiliates.  All rights reserved.