CN116302349A - The method of speeding up the startup speed of Java application program and its related components - Google Patents

Abstract

The application discloses a method for accelerating the starting speed of a Java application program and related components thereof, which are applied to a Java virtual machine, and relate to the technical field of computers, and comprise the following steps: loading and analyzing a target class file acquired from a disk by using a target class loader to generate a klass object; the target class loader is any one of a guide class loader, an extension class loader and an application program class loader; if the klass object can be shared, writing the full-limit name of the klass object into a preset sharing list; reading a preset sharing list, and loading a corresponding class file so as to write corresponding class data into a preset archive file; mapping a preset archive file into a memory in the starting process of a java application program, so that target class data corresponding to class loading operation is obtained from the memory after the class loading operation is triggered, and a system dictionary is updated by using the target class data. The class sharing range of CDS characteristics is enlarged, and the starting speed of the application program is improved.

Description

The method of speeding up the startup speed of Java application program and its related components

technical field

The invention relates to the field of computer technology, in particular to a method, device, equipment and medium for accelerating the startup speed of Java application programs.

Background technique

Under the current trend of increasing application volume, application business scenarios are complex and contain rich business functions, and its deployment package relies on many third-party technologies and business components, and its volume is relatively large. In the process of application startup, it is necessary to traverse and find a large number of third-party dependencies to complete the class loading process. Due to the large number of dependencies on JAR (Java Archive File) packages, the class loading process is longer and the startup time of the application is very long, so it is urgent The startup time of the application needs to be reduced. When the JVM (Java Virtual Machine, that is, the Java virtual machine) needs to use a certain class, the JVM will find the class file from the disk, load the class file, verify the bytecode file, prepare, parse, and initialize, according to its internal Only when the data structure is loaded into the memory can the class be used. However, this process takes up a lot of time. When the application is large and there are many classes to be loaded, it will take a lot of time for each class to go through the class loading step, reducing the application's performance. Boot speed. For the packaged JAR package, as long as the content of the JAR package remains unchanged, the data of the classes in the JAR package is always the same. The JVM runs the same loading steps every time it starts up, consuming a lot of time. JDK has already carried out relevant work on how to shorten the startup time of the application program, and introduced the CDS (Class-Data Sharing, class data sharing) feature.

The current CDS feature of the JDK is to let the JVM only do one loading, linking, and initialization actions, and then dump the class data into a file. When the JVM starts and needs to load a certain class, the JVM will first search for the required class from the dumped file, and if there is any required class data in the dumped file, it will be loaded into the JVM memory, and then execute if it is not found class loading process. However, the current CDS technology only supports classes loaded by Bootstrap classloader (bootstrap class loader) and Ext Classloader (extended class loader), which has limited improvement in application startup speed.

To sum up, how to further improve the startup speed of the application program is a problem to be solved at present.

Contents of the invention

In view of this, the object of the present invention is to provide a method, device, device and medium for accelerating the startup speed of Java applications, which can further improve the startup speed of applications. The specific plan is as follows:

In the first aspect, the application discloses a method for accelerating the startup speed of a Java application, which is applied to a Java virtual machine, including:

Obtain the target class file from the disk, and utilize the target class loader to load and parse the target class file to generate a corresponding klass object; wherein, the target class loader is a bootstrap class loader, an extension class loader and an application program Any class loader in the class loader;

Judging whether the klass object can be shared, if so, then writing the fully qualified name of the target class file into the preset sharing list;

reading the default shared list, and loading the class file corresponding to each of the fully qualified names, so as to write the corresponding class data into the default archive file;

During the startup process of the java application program, the preset archive file is mapped to the memory, so that after the class loading operation is triggered, the target class data corresponding to the class loading operation is obtained from the memory, and the target is used Class data updates the system dictionary.

Optionally, using the target class loader to load and parse the target class file to generate a corresponding klass object includes:

A corresponding target class loader is determined based on the directory information and path information of the target class file, so that the target class loader is used to load and parse the target class file to generate a corresponding klass object.

Optionally, the judging whether the klass object can be shared includes:

Based on the sharing class of the system dictionary, it is judged whether the klass object can be shared.

Optionally, after the judging whether the klass object can be shared, it also includes:

If not, it is determined that the fully qualified name of the target class file cannot be written into the default sharing list.

Optionally, reading the preset shared list, and loading the class file corresponding to each fully qualified name, so as to write the corresponding class data into the preset archive file, includes:

Read the fully qualified names in the preset shared list, and load the class files corresponding to each of the fully qualified names, until all the class files are loaded, write the corresponding class data into the preset archive file .

Optionally, the acquiring target class data corresponding to the class loading operation from the memory, and using the target class data to update the system dictionary includes:

Determine the target klass object corresponding to the class loading operation, and determine whether there is target class data corresponding to the target klass object in the memory;

If it exists, the target class data is acquired from the memory, and the system dictionary is updated with the target class data.

Optionally, after the judging whether there is target class data corresponding to the target klass object in the memory, it also includes:

If it does not exist, then use the class file corresponding to the class loading operation as the target class file;

Re-jump to the step of obtaining the target class file from the disk, and use the target class loader to load and parse the target class file to generate the corresponding klass object until the class load is obtained from the memory. Operate the corresponding target class data, and then use the target class data to update the system dictionary.

In the second aspect, the present application discloses a device for accelerating the startup speed of Java applications, which is applied to Java virtual machines, including:

The file loading module is used to obtain the target class file from the disk, and utilizes the target class loader to load and parse the target class file to generate a corresponding klass object; wherein, the target class loader is a bootstrap class loader, an extension Any one of the class loader and the application class loader;

Judging module, for judging whether the klass object can be shared, if so, then write the fully qualified name of the target class file into the preset sharing list;

an archive file writing module, configured to read the preset shared list, and load a class file corresponding to each fully qualified name, so as to write the corresponding class data into the preset archive file;

The mapping module is used to map the preset archive file into the memory during the startup process of the java application, so that after the class loading operation is triggered, the target class data corresponding to the class loading operation is obtained from the memory, And update the system dictionary with the target class data.

In a third aspect, the present application discloses an electronic device, comprising:

memory for storing computer programs;

The processor is configured to execute the computer program, so as to realize the steps of the aforementioned disclosed method for accelerating the startup speed of Java applications.

In a fourth aspect, the present application discloses a computer-readable storage medium for storing a computer program; wherein, when the computer program is executed by a processor, the steps of the aforementioned disclosed method for accelerating the startup speed of a Java application are implemented.

It can be seen that the present application obtains the target class file from the disk through the Java virtual machine, and uses the target class loader to load and parse the target class file to generate a corresponding klass object; wherein, the target class loader is a bootstrap class loader , any class loader in the extension class loader and the application program class loader; determine whether the klass object can be shared, if so, write the fully qualified name of the target class file into the preset sharing list; read Get the preset sharing list, and load the class file corresponding to each of the fully qualified names, so that the corresponding class data is written into the preset archive file; The archive file is mapped to the memory, so that after the class loading operation is triggered, the target class data corresponding to the class loading operation is obtained from the memory, and the system dictionary is updated with the target class data. It can be seen that, on the basis of supporting the classes loaded by the bootstrap class loader and the extended class loader, this application also increases the classes loaded by the application program class loader, expands the class sharing scope of the CDS feature, and greatly improves the Dumped classes significantly improve application startup speed. Then, after the Java virtual machine obtains the target class file from the disk, it uses the corresponding target class loader to record and analyze it, so that the corresponding class data is dumped into the preset archive file. When the java application starts Then directly map the preset archive file to the memory, then obtain the target class data corresponding to the current class loading operation from the memory, and use the target class data to update the system dictionary. The above process does not need to reload the class file to obtain the corresponding class data, which reduces the steps of class loading, shortens the startup time of the application program, and improves the startup speed of the application program.

Description of drawings

In order to more clearly illustrate the technical solutions in the embodiments of the present application or the prior art, the following will briefly introduce the drawings that need to be used in the description of the embodiments or the prior art. Obviously, the accompanying drawings in the following description are only It is an embodiment of the present invention, and those skilled in the art can also obtain other drawings according to the provided drawings without creative work.

Fig. 1 is a flow chart of a method for accelerating the startup speed of Java applications disclosed in the present application;

Fig. 2 is a schematic flow chart of accelerating the startup speed of a Java application disclosed in the present application;

Fig. 3 is a kind of flowchart of generating lst file disclosed by the present application;

FIG. 4 is a flow chart of a specific method for accelerating the startup speed of Java applications disclosed in the present application;

Fig. 5 is a kind of flow chart that generates jsa archive file disclosed by the application;

Fig. 6 is a kind of flowchart of using jsa archive file disclosed by the present application;

FIG. 7 is a schematic structural diagram of a device for accelerating the startup speed of a Java application disclosed in the present application;

FIG. 8 is a structural diagram of an electronic device disclosed in the present application.

Detailed ways

The following will clearly and completely describe the technical solutions in the embodiments of the present application with reference to the accompanying drawings in the embodiments of the present application. Obviously, the described embodiments are only some of the embodiments of the present invention, not all of them. Based on the embodiments of the present invention, all other embodiments obtained by persons of ordinary skill in the art without making creative efforts belong to the protection scope of the present invention.

The current CDS feature of the JDK is to let the JVM only do one loading, linking, and initialization actions, and then dump the class data into a file. When the JVM starts and needs to load a certain class, the JVM will first search for the required class from the dumped file, and if there is any required class data in the dumped file, it will be loaded into the JVM memory, and then execute if it is not found class loading process. However, the current CDS technology only supports classes loaded by Bootstrap classloader (bootstrap class loader) and Ext Classloader (extended class loader), which has limited improvement in application startup speed. To this end, the embodiment of the present application discloses a method, device, device, and medium for accelerating the startup speed of Java applications, which can further increase the startup speed of applications.

Referring to Fig. 1 and shown in Fig. 2, the embodiment of the present application discloses a method for accelerating the startup speed of a Java application, which is applied to a Java virtual machine, and the method includes:

Step S11: Obtain the target class file from the disk, and use the target class loader to load and parse the target class file to generate a corresponding klass object; wherein, the target class loader is a bootstrap class loader and an extended class loader and any of the application class loaders.

In this embodiment, when the Java virtual machine needs to use a certain class, the Java virtual machine finds and obtains the target class file from the disk, and generates a corresponding klass object after being loaded and parsed by the target class loader. As shown in FIG. 3 , the target class loader is any class loader among bootstrap class loader, extension class loader and application program class loader. That is to say, on the basis of supporting the classes loaded by the bootstrap class loader and the extended class loader, this application also increases the classes loaded by the application class loader, expands the class sharing scope of the CDS feature, and greatly improves the class that can be transferred. Stored classes can significantly improve the application startup speed.

Step S12: Determine whether the klass object can be shared, and if so, write the fully qualified name of the target class file into the preset sharing list.

In this embodiment, when judging whether the klass object can be shared, specifically includes: judging whether the klass object can be shared based on the shared class of the system dictionary. That is to say, this embodiment judges whether the klass object can be shared by the sharing class of the system dictionary, if the klass object can be shared, then write the fully qualified name of the target class file into the preset sharing list, wherein the preset sharing list is specifically lst file. That is, through the above solution, the classes that can be shared can be written into the lst file to generate the lst file.

Further, after determining whether the klass object can be shared, the method further includes: if not, determining that the fully qualified name of the target class file cannot be written into the preset sharing list. That is, if the klass object cannot be shared, it is determined that the fully qualified name of the target class file cannot be written into the default sharing list, that is, dumping cannot be performed.

Step S13: Read the preset sharing list, and load the class file corresponding to each fully qualified name, so as to write the corresponding class data into the preset archive file.

In this embodiment, the Java virtual machine reads the preset shared list, that is, reads the content in the lst file, and then loads the class file corresponding to each fully qualified name. After the class is loaded, the system dictionary (SystemDictionary) will be updated, and the Java virtual machine will write its corresponding data into the memory, and then dump this part of the data into the default archive file. The default archive file is specifically jsa archive. That is, through the above solution, the class data recorded in the lst file can be recorded into the jsa archive file, and the jsa archive file can be generated.

Step S14: Map the preset archive file into the memory during the startup process of the java application, so that after the class loading operation is triggered, the target class data corresponding to the class loading operation is obtained from the memory, and used The object class data updates the system dictionary.

In this embodiment, during the startup process of the java application program, the Java virtual machine maps the jsa archive file into the memory. After the class loading operation is triggered, the Java virtual machine first obtains the target class data corresponding to the class loading operation from the mapped memory, and after obtaining it, updates the system dictionary with the target class data. The above process does not need to reload the class file to obtain the corresponding class data, which reduces the steps of class loading, shortens the startup time of the application program, and improves the startup speed of the application program.

It can be seen that the present application obtains the target class file from the disk through the Java virtual machine, and uses the target class loader to load and parse the target class file to generate a corresponding klass object; wherein, the target class loader is a bootstrap class loader , any class loader in the extension class loader and the application program class loader; determine whether the klass object can be shared, if so, write the fully qualified name of the target class file into the preset sharing list; read Get the preset sharing list, and load the class file corresponding to each of the fully qualified names, so that the corresponding class data is written into the preset archive file; The archive file is mapped to the memory, so that after the class loading operation is triggered, the target class data corresponding to the class loading operation is obtained from the memory, and the system dictionary is updated with the target class data. It can be seen that, on the basis of supporting the classes loaded by the bootstrap class loader and the extended class loader, this application also increases the classes loaded by the application program class loader, expands the class sharing scope of the CDS feature, and greatly improves the Dumped classes significantly improve application startup speed. Then, after the Java virtual machine obtains the target class file from the disk, it uses the corresponding target class loader to record and analyze it, so that the corresponding class data is dumped into the preset archive file. When the java application starts Then directly map the preset archive file to the memory, then obtain the target class data corresponding to the current class loading operation from the memory, and use the target class data to update the system dictionary. The above process does not need to reload the class file to obtain the corresponding class data, which reduces the steps of class loading, shortens the startup time of the application program, and improves the startup speed of the application program.

Referring to FIG. 4 , the embodiment of the present application discloses a specific method for accelerating the startup speed of Java applications. Compared with the previous embodiment, this embodiment further explains and optimizes the technical solution. Specifically include:

Step S21: Obtain the target class file from the disk, and determine the corresponding target class loader based on the directory information and path information of the target class file, so as to use the target class loader to load and parse the target class file to generate The corresponding klass object; wherein, the target class loader is any class loader in the bootstrap class loader, extension class loader and application program class loader.

In this embodiment, the corresponding target class loader is determined based on the directory information and path information of the target class file. For example, the boot class loader is responsible for loading the jar packages and classes in the %JAVA_HOME%/lib directory or all classes in the path specified by the -Xbootclasspath parameter; the extension class loader is mainly responsible for loading the %JRE_HOME%/lib/ext directory jar packages and classes, or jar packages under the path specified by the java.ext.dirs system variable; the application class loader is a user-oriented loader responsible for loading all jar packages and classes under the classpath of the current application.

Step S22: Determine whether the klass object can be shared, and if so, write the fully qualified name of the target class file into the preset sharing list.

Step S23: Read the fully qualified names in the preset sharing list, and load the class files corresponding to each of the fully qualified names, until all the class files are loaded, write the corresponding class data to the preset in the archive.

In this embodiment, as shown in FIG. 5 , the Java virtual machine reads the content in the lst file, and then loads the corresponding class. After the class is loaded, the system dictionary will be updated. When all the corresponding class files in the lst file are loaded, the Java virtual machine will write the corresponding class data into the jsa archive file.

Step S24: Map the preset archive file into the memory during the startup process of the java application, so that after the class loading operation is triggered, determine the target klass object corresponding to the class loading operation, and determine whether the target klass object in the memory is There is target class data corresponding to the target klass object.

In this embodiment, as shown in FIG. 6 , the preset archive file is mapped to the memory during the startup process of the java application. After the class loading operation is triggered, first determine the target klass object corresponding to the class loading operation, and then determine whether there is target class data corresponding to the target klass object in the memory, that is, determine whether the target klass object corresponding to the target klass object can be obtained from the memory target class data.

Step S25: If it exists, acquire the target class data from the memory, and use the target class data to update the system dictionary.

In this embodiment, if there is target class data corresponding to the target klass object in the memory, the target class data is directly obtained from the memory, and the system dictionary is updated with the target class data. That is, this embodiment does not need to reload the class file to obtain the corresponding class data, but directly obtains the class data from the memory after the class data is mapped to the memory through the archive file, thereby reducing the class loading steps and shortening the startup of the application program time, improving the startup speed of the application.

In addition, after the above-mentioned judging whether there is target class data corresponding to the target klass object in the memory, it also includes: if it does not exist, using the class file corresponding to the class loading operation as the target class file; re-jumping To the step of obtaining the target class file from the disk, and using the target class loader to load and parse the target class file to generate a corresponding klass object, until the class corresponding to the class loading operation is obtained from the memory target class data, and then update the system dictionary with the target class data. That is, if the corresponding target class data does not exist in the memory, then execute the normal class loading process, that is, parsing, linking, initialization, and so on. The class file corresponding to the class loading operation is used as the target class file, and then jumps to the step of obtaining the target class file from the disk, and using the target class loader to load and parse the target class file to generate the corresponding klass object until from The target class data corresponding to the class loading operation is obtained in the memory, and then the system dictionary is updated with the target class data.

Wherein, for a more specific processing procedure of the above-mentioned step S22, reference may be made to the corresponding content disclosed in the foregoing embodiments, which will not be repeated here.

It can be seen that, after obtaining the target class file, the embodiment of the present application determines the corresponding target class loader according to its directory information and path information, and then uses the target class loader to load and parse it. In addition to the bootstrap class loader and extension class loader, the target class loader also includes the application class loader, thus expanding the class sharing range of the CDS feature, greatly increasing the classes that can be dumped, and significantly improving the startup speed of the application . In addition, after the class data is written into the archive file, the archive file is mapped to the memory during the java application startup process, so that after the class loading operation is triggered, if there is target class data corresponding to the target klass object in the memory, It can be obtained directly from the memory without reloading the class file to obtain the corresponding class data, which reduces the class loading steps, shortens the startup time of the application program, and improves the startup speed of the application program. If the target class data does not exist in the memory, then execute the normal class loading process.

Referring to Fig. 7, the embodiment of the present application discloses a device for accelerating the startup speed of Java applications, which includes:

File loading module 11, is used for obtaining target class file from disk, and utilizes target class loader to load and parse described target class file to generate corresponding klass object; Wherein, described target class loader is guide class loader, Any class loader in the extension class loader and the application class loader;

Judgment module 12, is used for judging whether described klass object can be shared, if so, then write the fully qualified name of described target class file into preset sharing list;

An archive file writing module 13, configured to read the preset shared list, and load a class file corresponding to each fully qualified name, so as to write the corresponding class data into the preset archive file;

The mapping module 14 is used to map the preset archive file into the memory during the startup process of the java application, so that after the class loading operation is triggered, the target class data corresponding to the class loading operation is obtained from the memory , and update the system dictionary with the target class data.

It can be seen that the present application obtains the target class file from the disk through the Java virtual machine, and uses the target class loader to load and parse the target class file to generate a corresponding klass object; wherein, the target class loader is a bootstrap class loader , any class loader in the extension class loader and the application program class loader; determine whether the klass object can be shared, if so, write the fully qualified name of the target class file into the preset sharing list; read Get the preset sharing list, and load the class file corresponding to each of the fully qualified names, so that the corresponding class data is written into the preset archive file; The archive file is mapped to the memory, so that after the class loading operation is triggered, the target class data corresponding to the class loading operation is obtained from the memory, and the system dictionary is updated with the target class data. It can be seen that, on the basis of supporting the classes loaded by the bootstrap class loader and the extended class loader, this application also increases the classes loaded by the application program class loader, expands the class sharing scope of the CDS feature, and greatly improves the Dumped classes significantly improve application startup speed. Then, after the Java virtual machine obtains the target class file from the disk, it uses the corresponding target class loader to record and analyze it, so that the corresponding class data is dumped into the preset archive file. When the java application starts Then directly map the preset archive file to the memory, then obtain the target class data corresponding to the current class loading operation from the memory, and use the target class data to update the system dictionary. The above process does not need to reload the class file to obtain the corresponding class data, which reduces the steps of class loading, shortens the startup time of the application program, and improves the startup speed of the application program.

FIG. 8 is a schematic structural diagram of an electronic device provided by an embodiment of the present application. Specifically, it may include: at least one processor 21 , at least one memory 22 , a power supply 23 , a communication interface 24 , an input/output interface 25 and a communication bus 26 . Wherein, the memory 22 is used to store a computer program, and the computer program is loaded and executed by the processor 21, so as to realize the method in the method for accelerating the startup speed of a Java application performed by an electronic device disclosed in any of the above-mentioned embodiments. related steps.

In this embodiment, the power supply 23 is used to provide working voltage for each hardware device on the electronic device 20; the communication interface 24 can create a data transmission channel between the electronic device 20 and external devices, and the communication protocol it follows is applicable Any communication protocol in the technical solution of the present application is not specifically limited here; the input and output interface 25 is used to obtain external input data or output data to the external, and its specific interface type can be selected according to specific application needs, here Not specifically limited.

Wherein, the processor 21 may include one or more processing cores, such as a 4-core processor, an 8-core processor, and the like. Processor 21 can adopt at least one hardware form in DSP (Digital Signal Processing, digital signal processing), FPGA (Field-Programmable Gate Array, field programmable gate array), PLA (Programmable Logic Array, programmable logic array) accomplish. Processor 21 may also include a main processor and a coprocessor, and the main processor is a processor for processing data in a wake-up state, also known as a CPU (Central Processing Unit, central processing unit); Low-power processor for processing data in standby state. In some embodiments, the processor 21 may be integrated with a GPU (Graphics Processing Unit, image processor), and the GPU is used for rendering and drawing the content to be displayed on the display screen. In some embodiments, the processor 21 may further include an AI (Artificial Intelligence, artificial intelligence) processor, where the AI processor is used to process computing operations related to machine learning.

In addition, the memory 22, as a resource storage carrier, can be a read-only memory, random access memory, magnetic disk or optical disk, etc., and the resources stored thereon include the operating system 221, computer program 222 and data 223, etc., and the storage method can be short-term storage or permanent storage.

Among them, the operating system 221 is used to manage and control each hardware device and computer program 222 on the electronic device 20, so as to realize the calculation and processing of the massive data 223 in the memory 22 by the processor 21, which can be Windows, Unix, Linux, etc. In addition to the computer program 222 that can be used to complete the method for accelerating the startup speed of the Java application program executed by the electronic device 20 disclosed in any of the above-mentioned embodiments, it can further include a computer program that can be used to complete other specific tasks . The data 223 may not only include data received by the electronic device and transmitted from an external device, but may also include data collected by its own input and output interface 25 and the like.

Further, the embodiment of the present application also discloses a computer-readable storage medium, in which a computer program is stored. When the computer program is loaded and executed by a processor, the accelerated Method steps performed during Java application startup speed.

Each embodiment in this specification is described in a progressive manner, each embodiment focuses on the difference from other embodiments, and the same or similar parts of each embodiment can be referred to each other. As for the device disclosed in the embodiment, since it corresponds to the method disclosed in the embodiment, the description is relatively simple, and for relevant details, please refer to the description of the method part.

Professionals can further realize that the units and algorithm steps of the examples described in conjunction with the embodiments disclosed herein can be implemented by electronic hardware, computer software or a combination of the two. In order to clearly illustrate the possible For interchangeability, in the above description, the composition and steps of each example have been generally described according to their functions. Whether these functions are executed by hardware or software depends on the specific application and design constraints of the technical solution. Skilled artisans may use different methods to implement the described functions for each specific application, but such implementation should not be regarded as exceeding the scope of the present application.

The steps of the methods or algorithms described in connection with the embodiments disclosed herein may be directly implemented by hardware, software modules executed by a processor, or a combination of both. Software modules can be placed in random access memory (RAM), internal memory, read-only memory (ROM), electrically programmable ROM, electrically erasable programmable ROM, registers, hard disk, removable disk, CD-ROM, or any other Any other known storage medium.

Finally, it should also be noted that in this text, relational terms such as first and second etc. are only used to distinguish one entity or operation from another, and do not necessarily require or imply that these entities or operations, any such actual relationship or order exists. Furthermore, the term "comprises", "comprises" or any other variation thereof is intended to cover a non-exclusive inclusion such that a process, method, article, or apparatus comprising a set of elements includes not only those elements, but also includes elements not expressly listed. other elements of or also include elements inherent in such a process, method, article, or device. Without further limitations, an element defined by the phrase "comprising a ..." does not exclude the presence of additional identical elements in the process, method, article or apparatus comprising said element.

A method, device, device and storage medium for accelerating the startup speed of Java applications provided by the present invention have been introduced in detail above. In this paper, specific examples have been used to illustrate the principle and implementation of the present invention. The above embodiments The description is only used to help understand the method of the present invention and its core idea; at the same time, for those of ordinary skill in the art, according to the idea of the present invention, there will be changes in the specific implementation and scope of application. In summary , the contents of this specification should not be construed as limiting the present invention.

Claims (10)

1. A method for accelerating the starting speed of Java application programs is characterized by being applied to a Java virtual machine and comprising the following steps:

obtaining a target class file from a disk, and loading and analyzing the target class file by using a target class loader to generate a corresponding klass object; the target class loader is any one kind of loader among a guide class loader, an extension class loader and an application program class loader;

judging whether the klass object can be shared, if so, writing the full-limit name of the target class file into a preset sharing list;

reading the preset sharing list, and loading class files corresponding to each full-limit name so as to write corresponding class data into preset archive files;

and mapping the preset archive file into a memory in the starting process of the java application program, so that after class loading operation is triggered, target class data corresponding to the class loading operation is obtained from the memory, and a system dictionary is updated by using the target class data.

2. The method for accelerating the start-up of a Java application according to claim 1, wherein said loading and parsing the object class file with the object class loader to generate the corresponding klass object comprises:

and determining a corresponding target class loader based on the directory information and the path information of the target class file so as to load and analyze the target class file by using the target class loader to generate a corresponding klass object.

3. The method for accelerating the start-up of a Java application according to claim 1, wherein said determining whether said klass object can be shared comprises:

and judging whether the klass object can be shared or not based on the sharing class of the system dictionary.

4. The method for accelerating the start-up of a Java application according to claim 1, further comprising, after said determining whether said klass object can be shared:

if not, judging that the full-limit name of the target class file cannot be written into a preset sharing list.

5. The method for accelerating the start-up speed of a Java application according to claim 1, wherein the reading the preset sharing list and loading the class file corresponding to each of the fully qualified names so as to write the corresponding class data into the preset archive file comprises:

and reading the full-limit names in the preset sharing list, loading class files corresponding to each full-limit name until all the class files are loaded, and writing corresponding class data into preset archive files.

6. The method for accelerating the start-up speed of a Java application according to any one of claims 1 to 5, wherein the obtaining the target class data corresponding to the class loading operation from the memory and updating the system dictionary using the target class data comprises:

determining a target class object corresponding to the class loading operation, and judging whether target class data corresponding to the target class object exists in the memory or not;

if so, acquiring the target class data from the memory, and updating a system dictionary by using the target class data.

7. The method for accelerating the start-up speed of a Java application according to claim 6, further comprising, after determining whether there is target class data corresponding to the target klass object in the memory:

if not, taking the class file corresponding to the class loading operation as a target class file;

and re-jumping to the step of acquiring the target class file from the disk, loading and analyzing the target class file by using a target class loader to generate a corresponding klass object until target class data corresponding to the class loading operation is acquired from the memory, and updating a system dictionary by using the target class data.

8. An apparatus for accelerating the starting speed of a Java application, which is applied to a Java virtual machine, comprising:

the file loading module is used for acquiring a target class file from the disk, and loading and analyzing the target class file by utilizing a target class loader to generate a corresponding klass object; the target class loader is any one kind of loader among a guide class loader, an extension class loader and an application program class loader;

the judging module is used for judging whether the klass object can be shared or not, if so, writing the full-limit name of the target class file into a preset sharing list;

the archive file writing module is used for reading the preset sharing list, and loading class files corresponding to each full-limit name so as to write corresponding class data into the preset archive file;

the mapping module is used for mapping the preset archive file into a memory in the starting process of the java application program so as to acquire target class data corresponding to class loading operation from the memory after class loading operation is triggered, and updating a system dictionary by utilizing the target class data.

9. An electronic device, comprising:

a memory for storing a computer program;

a processor for executing the computer program to implement the steps of the method for accelerating the start-up speed of a Java application according to any one of claims 1 to 7.

10. A computer-readable storage medium storing a computer program; wherein the computer program when executed by a processor implements the steps of a method of accelerating the start-up of a Java application according to any of claims 1 to 7.

Images