CN107463425B - Method and device for acquiring running state of Java virtual machine - Google Patents
Method and device for acquiring running state of Java virtual machine Download PDFInfo
- Publication number
- CN107463425B CN107463425B CN201610391262.4A CN201610391262A CN107463425B CN 107463425 B CN107463425 B CN 107463425B CN 201610391262 A CN201610391262 A CN 201610391262A CN 107463425 B CN107463425 B CN 107463425B
- Authority
- CN
- China
- Prior art keywords
- file
- virtual machine
- java virtual
- creating
- running state
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45533—Hypervisors; Virtual machine monitors
- G06F9/45558—Hypervisor-specific management and integration aspects
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45533—Hypervisors; Virtual machine monitors
- G06F9/45558—Hypervisor-specific management and integration aspects
- G06F2009/45591—Monitoring or debugging support
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
Abstract
The application discloses a method and a device for acquiring running state of a Java virtual machine, wherein the method comprises the following steps: acquiring a process identifier of a Java virtual machine running in an LXC container in a host machine, wherein the running state of the Java virtual machine is recorded in a first file; creating a second file according to the process identifier, wherein the second file references the inode number of the first file in the file system; and acquiring the running state of the Java virtual machine from the second file. And enabling the host machine to acquire the running state of the Java virtual machine running in the LXC container.
Description
Technical Field
The application belongs to the technical field of computers, and particularly relates to a method and a device for acquiring a running state of a Java virtual machine.
Background
The Linux Container (LXC) Container is a kernel virtualization technology that can provide lightweight virtualization to isolate processes and resources without the need to provide instruction interpretation mechanisms and other complexities of full virtualization. The LXC container provides a mechanism to support simultaneous execution of multiple server containers isolated from each other on a single controllable host node. The Linux Container is somewhat like a socket, providing a virtual environment with its own processes and network space, but is different from a virtual machine because the LXC Container is a virtualization of resources on the operating system level.
A plurality of Java virtual machines can be started in a host machine at the same time, so that the resource utilization rate is improved, and meanwhile, the isolation among resources and the data security need to be considered. The isolation of resources such as a CPU (Central processing Unit) and a Memory (Memory) of each Java virtual machine is realized through the LXC, and the data access authority of each Java virtual machine is realized by using a Linux user space. Therefore, the Java virtual machine is typically started under a certain user space using LXC.
Disclosure of Invention
In view of this, the present application provides a method and an apparatus for acquiring an operating state of a Java virtual machine, so as to solve a problem that a monitoring data acquisition script in a host cannot acquire an operating state of a Java virtual machine in an LXC container.
In order to solve the technical problem, the application discloses a method for acquiring an operating state of a Java virtual machine, including: acquiring a process identifier of a Java virtual machine running in an LXC container in a host machine, wherein the running state of the Java virtual machine is recorded in a first file; creating a second file according to the process identifier, wherein the second file references the inode number of the first file in the file system; and acquiring the running state of the Java virtual machine from the second file.
In order to solve the above technical problem, the present application further discloses an apparatus for acquiring an operating state of a Java virtual machine, including: the system comprises a first acquisition module, a first storage module and a second storage module, wherein the first acquisition module is used for acquiring a process identifier of a Java virtual machine running in an LXC container in a host, and the running state of the Java virtual machine is recorded in a first file; the creating module is used for creating a second file according to the process identifier, and the second file refers to the index node number of the first file in the file system; and the second acquisition module is used for acquiring the running state of the Java virtual machine from the second file.
Compared with the prior art, the application can obtain the following technical effects: the host machine can obtain the running state of the Java virtual machine running in the LXC container, and the host machine can be used as a reference for adjusting and optimizing the running parameters of the Java virtual machine and expanding the capacity of the application example.
Of course, it is not necessary for any one product to achieve all of the above-described technical effects simultaneously.
Drawings
The accompanying drawings, which are included to provide a further understanding of the application and are incorporated in and constitute a part of this application, illustrate embodiment(s) of the application and together with the description serve to explain the application and not to limit the application. In the drawings:
fig. 1 is a flowchart of a method for acquiring an operating state of a Java virtual machine according to an embodiment of the present application;
FIG. 2 is a flowchart of a method for acquiring an operating state of a Java virtual machine according to an embodiment of the present application;
FIG. 3 is a flowchart of a method for acquiring an operating state of a Java virtual machine according to an embodiment of the present application;
fig. 4 is a block diagram of an apparatus for acquiring an operating state of a Java virtual machine according to an embodiment of the present application.
Detailed Description
Embodiments of the present application will be described in detail with reference to the drawings and examples, so that how to implement technical means to solve technical problems and achieve technical effects of the present application can be fully understood and implemented.
When the Java virtual machine is started, the Process of the Java virtual machine is recorded in a directory for storing temporary files, and a file is named by a Process Identification (PID), through which the real-time running state of the Java instance is recorded.
When the Java virtual machine is started under the LXC container, the process is recorded under a directory for storing temporary files, and a file is named by the PID of the Java virtual machine in the LXC container. At this time, the PID naming the file is not the PID of the process under the host, so that an Agent (Agent) in the host (e.g., QEMU client Agent, QEMU Guest Agent) cannot acquire the running state of the Java virtual machine.
The inventors of the present application have found that, in order to solve the above problem, it is necessary to acquire a PID of a Java Virtual Machine process inside an LXC container under a host, and synchronize the content of a first file named by the PID inside the LXC container into a second file named by the PID under the host, so that the host can acquire the operating state of the Java Virtual Machine inside the LXC container by attaching the second file to a Java Virtual Machine state monitoring tool (Java Virtual Machine monitoring tool, jstat).
Then, after allocating corresponding resources and user spaces for the respective different Java virtual machines by using the LXC container, the Java virtual machines are started in the LXC container. For example, lxc-execute-n name [ -fconfig _ file ] [ -s KEY ═ VAL ] command; where name represents the container name, config _ file represents the path of the container configuration file, KEY ═ VAL represents the configuration KEY value pair, and command represents the command to be executed.
After the Java virtual machine is started in the LXC container, the PID of the Java virtual machine in the LXC container is acquired. A Java virtual machine process in an LXC container can be queried through the LXC-ps command to obtain the PID of the Java virtual machine, e.g., LXC-ps-n foo, where foo is the name of the container to be queried.
And creating a first file according to the PID of the Java virtual machine in the LXC container. The file name of the first file is the PID of the Java virtual machine in the LXC container.
And acquiring the PID of the Java virtual machine in the host machine through a preset command. The PID of the Java virtual machine under the host can be queried through a ps command under Linux, for example, ps-C name, wherein the name represents the name of the Java virtual machine.
And creating a second file according to the PID of the Java virtual machine under the host machine, wherein the name of the second file is the PID of the Java virtual machine under the host machine. And the second file references an inode number of the first file in the file system, such that the first file and the second file are the same file for the file system.
Then, when the running state of the Java virtual machine in the LXC container is recorded in the first file, the corresponding data will also appear in the second file synchronously. At this time, the second file can be attached through the script command of the host machine, and the running state of the Java virtual machine in the LXC container can be obtained.
In one embodiment, the second file references the inode number of the first file in the file system by using the second file as a hard link file for the first file.
At this time, the file name of the first file is the PID of the Java virtual machine in the LXC container, and the file name of the second file is the PID of the Java virtual machine in the host. The file name of the first file and the file name of the second file are linked by the inode number through a hard link, and at this time, the first file and the second file are still the same file but have different file names for the file system. The hard link resembles a pointer to an inode number of the file system that does not reassign inodes to the hard link file.
Hard links can only reference files in the same file system. It references an inode (called an inode) of a file in the file system. When the original file is moved or deleted, the hard link cannot be damaged, the hard link file does not need the user to have the right of accessing the original file, and the position of the original file cannot be displayed, so that the file security is facilitated.
The hard link may be established with an ln command, for example, an ln existingfile newfile, where existingfile is the file of the original file and newfile is the newly created hard link file.
Since the running state of the Java virtual machine in the LXC container is recorded in the first file, the running state of the Java virtual machine is synchronized into the second file after the second file becomes a hard link file of the first file.
When the host machine acquires the running state of the Java virtual machine in the LXC container from a second file, the second file can be attached through a jstat-gcutil { PID } command, wherein PID represents the PID of the Java virtual machine in the host machine and is also the file name of the second file.
Through the method, the host machine can acquire the running state of the Java virtual machine in the LXC container. The running state comprises the use condition of the Java heap during the running period of the Java virtual machine, such as garbage recovery times, garbage recovery time and the like, and can be used as reference for adjusting and optimizing running parameters of the Java virtual machine and expanding the capacity of an application instance.
The second file may be created under the same directory as the first file, for example, a/tmp/hsperfdata _ { user } directory under which a/hsperfdata _ { user } directory is regenerated each time a Java virtual machine is started, wherein the user represents the user who started the Java virtual machine, the first file recording the operating state of the Java virtual machine is generated under the/tmp/hsperfdata _ { user } directory, and the second file may also be created under the/tmp/hsperfdata _ { user } directory. And the second file can be created under a different directory than the first file, so that the original file and the hard link file can be managed more conveniently and differently.
Since the first file directly recording the running state of the Java virtual machine is stored in the/tmp directory, i.e. the temporary file directory, the content of the first file is cleared after the Java virtual machine exits, or the storage space occupied by the first file is too large and needs to be cleared because the running time of the Java virtual machine is long. Therefore, in order to completely save the historical operating state of the Java virtual machine, the data acquired from the second file is persistently saved in the nonvolatile storage medium, so as to ensure that the acquired operating state data is not lost.
When the host runs one or more Java virtual machines in the LXC container, a first file created according to the PID of each Java virtual machine under the LXC container and a second file created according to the PID of each Java virtual machine in the host are stored in a file system of the host, wherein the second file is a hard link file of the first file. In the file system of the host, the second file may be stored in the same directory as the first file, or may be stored in different directories. When the first file and the second file are respectively stored in different directories, the original file and the hard link file can be managed more conveniently. And the host machine acquires the running state of the Java virtual machine from the corresponding second file according to the PID of the Java virtual machine in the host machine.
The host may be a computer, a Platform-as-a-Service (PaaS) Platform, or the like.
When the method for acquiring the running state of the Java virtual machine provided by the embodiment of the application is applied to a PaaS platform, corresponding user space and system resources are firstly allocated to different users, and the different users run or develop respective application services under different LXC containers.
In order to monitor the running state and resource use condition of the application service run by each user, the PaaS platform obtains the process identifier of the Java virtual machine, which is run by each user in each LXC container, in the PaaS platform. And creating a second file according to the process identification, wherein the second file refers to the inode number of the first file in the PaaS platform file system, and the first file is created when the Java virtual machine is started in the LXC container. And acquiring the running state of the corresponding Java virtual machine by attaching the second file under the PaaS platform.
Based on the above discussion, the method for the host to obtain the running state of the Java virtual machine in the embodiment of the present application is shown in fig. 1, and includes the following steps.
S10, acquiring a process identifier of the Java virtual machine running in the LXC container in the host, wherein the running state of the Java virtual machine is recorded in a first file;
s11, creating a second file according to the process identifier, wherein the second file refers to the index node number of the first file in the file system;
and S12, acquiring the running state of the Java virtual machine from the second file.
By the method, the host machine obtains the running state of the Java virtual machine running in the LXC container, and the running state is referred to the tuning of the running parameters of the Java virtual machine and the capacity expansion of the application example.
In another embodiment, the first file is stored under a first directory and the second file is stored under a second directory. For example, a first file is created under directory/home/admin/LXC 1, the name of the first file is the PID of the Java virtual machine within the LXC container, a second file is created under directory/home/admin/named the PID of the Java virtual machine at the host, and the second file is a hard-linked file of the first file.
In another embodiment, the step S11 further includes:
and S110, creating a second file according to the process identification, and establishing a hard link between the second file and the first file.
In one embodiment, as shown in fig. 2, the method for acquiring the running state of the Java virtual machine further includes:
and S13, allocating corresponding user space and system resources for the Java virtual machine.
In another embodiment, the step S11 further includes:
and S111, creating the second file under a different directory from the first file.
In another embodiment, the step S11 further includes:
s112, the second file and the first file are created under a/tmp/hsperfdata _ { user } directory.
In another embodiment, the step S12 further includes:
and S120, attaching the second file through a jstat-gcutil { pid } command to acquire the running state of the Java virtual machine.
In another embodiment, the step S10 further includes:
s100, under the PaaS platform, acquiring a process identifier of a Java virtual machine, which runs in an LXC container, of a user in the PaaS platform.
In another embodiment, as shown in fig. 3, the method for acquiring the running state of the Java virtual machine further includes:
and S14, performing persistent storage on the acquired running state of the Java virtual machine.
The following are apparatus embodiments of the present application for performing the above-described method embodiments of the present application.
Fig. 4 is a device for acquiring an operating state of a Java virtual machine according to an embodiment of the present application, including:
a first obtaining module 20, configured to obtain a process identifier of a Java virtual machine running in an LXC container in a host, where a running state of the Java virtual machine is recorded in a first file;
a creating module 21, configured to create a second file according to the process identifier, where the second file references an inode number of the first file in the file system;
and a second obtaining module 22, configured to obtain the running state of the Java virtual machine from the second file.
In one embodiment, the creation module 22 further comprises:
and the first creating submodule is used for creating a second file according to the process identification and establishing a hard link between the second file and the first file.
In one embodiment, the apparatus further comprises:
and the allocation module is used for allocating corresponding user space and system resources for the Java virtual machine.
In one embodiment, the creation module 22 further comprises:
and the second creating sub-module is used for creating a second file under a different directory from the first file.
In one embodiment, the creation module 22 further comprises:
and a third creating sub-module for creating the second file and the first file in the/tmp/hsperfdata _ { user } directory.
In one embodiment, the second obtaining module 22 further comprises:
and the attachment sub-module is used for attaching the second file through a jstat-gcutil { pid } command to acquire the running state of the Java virtual machine.
In one embodiment, the first obtaining module 20 further includes:
and the obtaining submodule is used for obtaining the process identifier of the Java virtual machine, which runs in the LXC container, in the PaaS platform.
In one embodiment, the apparatus further comprises:
and the persistence module is used for performing persistence storage on the acquired running state of the Java virtual machine.
In addition, in the embodiment of the present application, each functional module may be implemented by a hardware processor (hardware processor).
An embodiment of the present application further provides a device for obtaining an operating state of a Java virtual machine, including: a processor; a memory for storing the processor-executable instructions; wherein the processor is configured to:
acquiring a process identifier of a Java virtual machine running in an LXC container in a host machine, wherein the running state of the Java virtual machine is recorded in a first file; creating a second file according to the process identifier, wherein the second file references the inode number of the first file in the file system; and acquiring the running state of the Java virtual machine from the second file.
In one embodiment, creating a second file according to the process identifier, the second file referencing an inode number of the first file in a file system includes:
and creating a second file according to the process identification, and establishing a hard link between the second file and the first file.
In one embodiment, prior to said obtaining the process identification of the Java virtual machine running in the LXC container in the host, the processor is further configured to:
and distributing corresponding user space and system resources for the Java virtual machine.
In one embodiment, creating the second file according to the process identification comprises:
the second file is created under a different directory than the first file.
In one embodiment, creating the second file according to the process identification comprises:
and creating the second file and the first file in a/tmp/hsperfdata _ { user } directory.
In an embodiment, the obtaining the running state of the Java virtual machine from the second file includes:
and attaching the second file through a jstat-gcutil { pid } command to acquire the running state of the Java virtual machine.
In one embodiment, the acquiring process identification of the Java virtual machine running in the LXC container in the host includes:
under the PaaS platform, acquiring a process identifier of a Java virtual machine, which runs in an LXC container, of a user in the PaaS platform.
In one embodiment, the processor is further configured to:
and performing persistent storage on the acquired running state of the Java virtual machine.
Furthermore, embodiments of the present application also provide a non-transitory computer-readable storage medium, such as a memory, including instructions, which are executable by a processor of an apparatus to perform the above method of obtaining an operating state of a Java virtual machine. For example, the non-transitory computer readable storage medium may be a ROM, a Random Access Memory (RAM), a CD-ROM, a magnetic tape, a floppy disk, an optical data storage device, and the like.
In a typical configuration, a computing device includes one or more processors (CPUs), input/output interfaces, network interfaces, and memory.
The memory may include forms of volatile memory in a computer readable medium, Random Access Memory (RAM) and/or non-volatile memory, such as Read Only Memory (ROM) or flash memory (flash RAM). Memory is an example of a computer-readable medium.
Computer-readable media, including both non-transitory and non-transitory, removable and non-removable media, may implement information storage by any method or technology. The information may be computer readable instructions, data structures, modules of a program, or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), Static Random Access Memory (SRAM), Dynamic Random Access Memory (DRAM), other types of Random Access Memory (RAM), Read Only Memory (ROM), Electrically Erasable Programmable Read Only Memory (EEPROM), flash memory or other memory technology, compact disc read only memory (CD-ROM), Digital Versatile Discs (DVD) or other optical storage, magnetic cassettes, magnetic tape magnetic disk storage or other magnetic storage devices, or any other non-transmission medium that can be used to store information that can be accessed by a computing device. As defined herein, computer readable media does not include non-transitory computer readable media (transient media), such as modulated data signals and carrier waves.
As used in the specification and in the claims, certain terms are used to refer to particular components. As one skilled in the art will appreciate, manufacturers may refer to a component by different names. This specification and claims do not intend to distinguish between components that differ in name but not function. In the following description and in the claims, the terms "include" and "comprise" are used in an open-ended fashion, and thus should be interpreted to mean "include, but not limited to. "substantially" means within an acceptable error range, and a person skilled in the art can solve the technical problem within a certain error range to substantially achieve the technical effect. Furthermore, the term "coupled" is intended to encompass any direct or indirect electrical coupling. Thus, if a first device couples to a second device, that connection may be through a direct electrical coupling or through an indirect electrical coupling via other devices and couplings. The description which follows is a preferred embodiment of the present application, but is made for the purpose of illustrating the general principles of the application and not for the purpose of limiting the scope of the application. The protection scope of the present application shall be subject to the definitions of the appended claims.
It is also noted that the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a good or system that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such good or system. Without further limitation, an element defined by the phrase "comprising an … …" does not exclude the presence of other like elements in a commodity or system that includes the element.
The foregoing description shows and describes several preferred embodiments of the present application, but as aforementioned, it is to be understood that the application is not limited to the forms disclosed herein, but is not to be construed as excluding other embodiments and is capable of use in various other combinations, modifications, and environments and is capable of changes within the scope of the inventive concept as expressed herein, commensurate with the above teachings, or the skill or knowledge of the relevant art. And that modifications and variations may be effected by those skilled in the art without departing from the spirit and scope of the application, which is to be protected by the claims appended hereto.
Claims (16)
1. A method for acquiring the running state of a Java virtual machine is characterized by comprising the following steps:
acquiring a process identifier of a Java virtual machine running in an LXC container in a host machine, wherein the running state of the Java virtual machine is recorded in a first file;
creating a second file according to the process identifier, wherein the second file references the inode number of the first file in the file system;
and acquiring the running state of the Java virtual machine from the second file.
2. The method of claim 1, wherein creating a second file according to the process identifier, the second file referencing an inode number of the first file in a file system comprises:
and creating a second file according to the process identification, and establishing a hard link between the second file and the first file.
3. The method of claim 1, wherein prior to said obtaining process identification of the Java virtual machine running in the LXC container in the host, the method further comprises:
and distributing corresponding user space and system resources for the Java virtual machine.
4. The method of claim 1, wherein creating a second file according to the process identifier comprises:
the second file is created under a different directory than the first file.
5. The method of claim 1, wherein creating a second file according to the process identifier comprises:
and creating the second file and the first file in a/tmp/hsperfdata _ { user } directory.
6. The method according to claim 1, wherein the obtaining the running state of the Java virtual machine from the second file comprises:
and attaching the second file through a jstat-gcutil { pid } command to acquire the running state of the Java virtual machine.
7. The method of claim 1, wherein obtaining process identification of a Java virtual machine running in an LXC container in a host comprises:
under the PaaS platform, acquiring a process identifier of a Java virtual machine, which runs in an LXC container, of a user in the PaaS platform.
8. The method of claim 1, further comprising:
and performing persistent storage on the acquired running state of the Java virtual machine.
9. An apparatus for acquiring an operating state of a Java virtual machine, comprising:
the system comprises a first acquisition module, a first storage module and a second storage module, wherein the first acquisition module is used for acquiring a process identifier of a Java virtual machine running in an LXC container in a host, and the running state of the Java virtual machine is recorded in a first file;
the creating module is used for creating a second file according to the process identifier, and the second file refers to the index node number of the first file in the file system;
and the second acquisition module is used for acquiring the running state of the Java virtual machine from the second file.
10. The apparatus of claim 9, wherein the creation module comprises:
and the first creating submodule is used for creating a second file according to the process identification and establishing a hard link between the second file and the first file.
11. The apparatus of claim 9, further comprising:
and the allocation module is used for allocating corresponding user space and system resources for the Java virtual machine.
12. The apparatus of claim 9, wherein the creation module comprises:
and the second creating sub-module is used for creating the second file under a different directory from the first file.
13. The apparatus of claim 9, wherein the creation module comprises:
and the third creating submodule is used for creating the second file and the first file in a/tmp/hsperfdata _ { user } directory.
14. The apparatus of claim 9, wherein the second obtaining module comprises:
and the attachment sub-module is used for attaching the second file through a jstat-gcutil { pid } command to acquire the running state of the Java virtual machine.
15. The apparatus of claim 9, wherein the first obtaining module comprises:
and the obtaining submodule is used for obtaining the process identifier of the Java virtual machine, which runs in the LXC container, in the PaaS platform.
16. The apparatus of claim 9, further comprising:
and the persistence module is used for performing persistence storage on the acquired running state of the Java virtual machine.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201610391262.4A CN107463425B (en) | 2016-06-03 | 2016-06-03 | Method and device for acquiring running state of Java virtual machine |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201610391262.4A CN107463425B (en) | 2016-06-03 | 2016-06-03 | Method and device for acquiring running state of Java virtual machine |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN107463425A CN107463425A (en) | 2017-12-12 |
| CN107463425B true CN107463425B (en) | 2021-03-05 |
Family
ID=60544969
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201610391262.4A Active CN107463425B (en) | 2016-06-03 | 2016-06-03 | Method and device for acquiring running state of Java virtual machine |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN107463425B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109189560A (en) * | 2018-09-13 | 2019-01-11 | 杭州数梦工场科技有限公司 | A kind of configuration method, device, equipment and the medium of JVM operating parameter |
Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN103544090A (en) * | 2013-10-16 | 2014-01-29 | 北京航空航天大学 | Method and device for monitoring virtual machine process |
| CN105278996A (en) * | 2015-11-03 | 2016-01-27 | 亚信科技（南京）有限公司 | Log collection method and device and log service system |
Family Cites Families (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US6445458B1 (en) * | 1998-12-03 | 2002-09-03 | International Business Machines Corporation | Method and system for virtual machine rendering of non-Latin1 Unicode glyphs |
| US8386749B2 (en) * | 2010-03-16 | 2013-02-26 | Advanced Micro Devices, Inc. | Address mapping in virtualized processing system |
| CN102394923A (en) * | 2011-10-27 | 2012-03-28 | 周诗琦 | Cloud system platform based on n*n display structure |
| US9450885B2 (en) * | 2012-03-26 | 2016-09-20 | Oracle International Corporation | System and method for supporting live migration of virtual machines in a virtualization environment |
| CN103365758B (en) * | 2013-08-05 | 2016-03-16 | 北京搜狐新媒体信息技术有限公司 | Process monitoring method under a kind of virtualized environment and system |
| CN105573819A (en) * | 2015-12-11 | 2016-05-11 | 国云科技股份有限公司 | Method for obtaining disk capacity information of virtual machine directly through host machine |
-
2016
- 2016-06-03 CN CN201610391262.4A patent/CN107463425B/en active Active
Patent Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN103544090A (en) * | 2013-10-16 | 2014-01-29 | 北京航空航天大学 | Method and device for monitoring virtual machine process |
| CN105278996A (en) * | 2015-11-03 | 2016-01-27 | 亚信科技（南京）有限公司 | Log collection method and device and log service system |
Non-Patent Citations (2)
| Title |
|---|
| GUIdock: Using Docker Containers with a Common Graphics User Interface to Address the Reproducibility of Research;Hung, Ling-Hong 等;《PLOS ONE》;20160405;第11卷(第4期);第1-5页 * |
| 基于Equinox的OSGI构件监控模块的研究与设计;严晓炜;《中国优秀硕士学位论文全文数据库_信息科技辑》;20120815(第8期);第I138-328页 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN107463425A (en) | 2017-12-12 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US11392400B2 (en) | Enhanced migration of clusters based on data accessibility | |
| EP2765508B1 (en) | Installation method and installation device for application software | |
| CN108023742B (en) | Application capacity expansion method, device and system | |
| US8924954B2 (en) | Application software installation method and application software installation apparatus | |
| US10013213B2 (en) | Container migration utilizing state storage of partitioned storage volume | |
| US11030025B2 (en) | Managing inter-process communications in a containerized application environment | |
| CN111930473B (en) | Method and apparatus for deploying image recognition service on container cloud | |
| CN108268609B (en) | File path establishing and accessing method and device | |
| US20160182315A1 (en) | Container manager | |
| CN107544864B (en) | Virtual machine data copying method and virtual machine data copying system | |
| CN109597626B (en) | Component deployment method and device | |
| CN111897623B (en) | Cluster management method, device, equipment and storage medium | |
| CN106886434B (en) | Distributed application installation method and device | |
| EP3037964B1 (en) | Virtual application manager in a cloud computing environment | |
| WO2020029995A1 (en) | Application upgrading through sharing dependencies | |
| US20230115261A1 (en) | Migrating stateful workloads between container clusters with different storage backends | |
| US20190392136A1 (en) | Sandboxing of software plug-ins | |
| CN112698979A (en) | Method and device for processing zookeeper double nodes, storage medium and processor | |
| CN113296891B (en) | Platform-based multi-scene knowledge graph processing method and device | |
| CN107463425B (en) | Method and device for acquiring running state of Java virtual machine | |
| US9485308B2 (en) | Zero copy volume reconstruction | |
| US10552404B2 (en) | Retrospective snapshots in log-structured storage systems | |
| CN113157392B (en) | High-availability method and equipment for mirror image warehouse | |
| US11262932B2 (en) | Host-aware discovery and backup configuration for storage assets within a data protection environment | |
| CN111078135B (en) | Enhanced data storage for virtual nodes in a data processing environment |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant | ||
| TR01 | Transfer of patent right |
Effective date of registration: 20230602 Address after: Room 1-2-A06, Yungu Park, No. 1008 Dengcai Street, Sandun Town, Xihu District, Hangzhou City, Zhejiang Province Patentee after: Aliyun Computing Co.,Ltd. Address before: Box 847, four, Grand Cayman capital, Cayman Islands, UK Patentee before: ALIBABA GROUP HOLDING Ltd. |
|
| TR01 | Transfer of patent right |