CN114625433B - Application startup method and system - Google Patents

Abstract

The disclosed embodiment provides an application startup method and system, the method comprising: receiving a startup instruction input by a user for a target application; reading startup data that the target application needs to access in a page cache memory according to the startup instruction, and starting the target application according to the startup data, wherein the startup data that the target application needs to access is input/output operation data of the target application in the startup phase collected in advance and stored in the page cache memory. The disclosed embodiment can improve the startup speed of the application, thereby improving the user experience.

Description

Application startup method and system

Technical Field

The embodiments of the present disclosure relate to the field of computer technology, and more particularly to a method and system for starting an application program.

Background technique

With the development of Internet technology, especially the advent of the mobile Internet era, the application and development of various applications on terminals have been promoted. In addition to more and more functional requirements for applications, people also have higher and higher requirements for the startup and running speed of applications.

In the related art, during the startup of an application, the stages of starting to run, input/output (IO) request, sleep and data preparation all take a certain amount of time. Among them, IO request means that when an application on a terminal device is started, the application needs to request some startup data from the kernel, and then proceed to the next step after receiving the data returned by the kernel.

However, when an application is started, the problem of blocking input/output (IO) often occurs. For example, when requesting interface data from the kernel, if the interface data is currently occupied by other programs and has not been released, the currently started application cannot quickly receive the interface data returned by the kernel. The current application will remain in a waiting state and cannot proceed to the next step, resulting in slow application startup and affecting user experience.

Summary of the invention

The embodiments of the present disclosure provide an application startup method and system to overcome the technical problem in the prior art that an application is blocked during startup, resulting in a slow startup speed.

In a first aspect, an embodiment of the present disclosure provides a method for starting an application program, including:

Receiving a start instruction input by a user for a target application;

The startup data that the target application needs to access is read from the page cache memory according to the startup instruction, and the target application is started according to the startup data. The startup data that the target application needs to access is the input/output operation data of the target application in the startup phase collected in advance and stored in the page cache memory.

In a second aspect, an embodiment of the present disclosure provides an application startup system, including:

A receiving module, used for receiving a start instruction input by a user for a target application program;

A startup module is used to read the startup data that the target application needs to access in the page cache memory according to the startup instruction, and start the target application according to the startup data. The startup data that the target application needs to access is the input/output operation data of the target application in the startup phase collected in advance and stored in the page cache memory.

In a third aspect, an embodiment of the present disclosure provides an electronic device, including: at least one processor and a memory;

The memory stores computer-executable instructions;

The at least one processor executes the computer-executable instructions stored in the memory, so that the at least one processor executes the application startup method described in the first aspect and various possible designs of the first aspect.

In a fourth aspect, an embodiment of the present disclosure provides a computer-readable storage medium, in which computer execution instructions are stored. When a processor executes the computer execution instructions, the application startup method described in the first aspect and various possible designs of the first aspect is implemented.

The present embodiment provides an application startup method and system. The method collects IO operation data of the target application in the startup phase in advance and stores it in a page cache memory. When a startup instruction input by the user for the target application is received, the startup data that the target application needs to access is directly read from the page cache memory, thereby avoiding direct reading of data from the disk when the application is started, solving the problem of startup blocking IO, speeding up the startup speed of the application, and improving the user experience.

BRIEF DESCRIPTION OF THE DRAWINGS

In order to more clearly illustrate the embodiments of the present disclosure or the technical solutions in the prior art, the drawings required for use in the embodiments or the description of the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of the present disclosure. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative labor.

FIG1 is a schematic diagram showing the time consumption ratio of each state when an application is started in the prior art;

FIG. 2 is an application scenario diagram 1 of the application startup method provided by an embodiment of the present disclosure;

FIG3 is a flowchart of a method for starting an application program provided in an embodiment of the present disclosure;

FIG4 is a second flow chart of the method for starting an application program provided in an embodiment of the present disclosure;

FIG5 is a second application scenario diagram of the application startup method provided by an embodiment of the present disclosure;

FIG6a is a third application scenario diagram of the application startup method provided by an embodiment of the present disclosure;

FIG6b is a fourth application scenario diagram of the application startup method provided by an embodiment of the present disclosure;

FIG6c is a fifth application scenario diagram of the application startup method provided by an embodiment of the present disclosure;

FIG7 is a schematic diagram of the structure of an application startup system provided by an embodiment of the present disclosure;

FIG8 is a schematic diagram of the structure of a pre-reading module in an application startup system provided by an embodiment of the present disclosure;

FIG. 9 is a schematic diagram of the hardware structure of an electronic device provided in an embodiment of the present disclosure.

Detailed ways

In order to make the purpose, technical solution and advantages of the embodiments of the present disclosure clearer, the technical solution in the embodiments of the present disclosure will be clearly and completely described below in conjunction with the drawings in the embodiments of the present disclosure. Obviously, the described embodiments are part of the embodiments of the present disclosure, not all of the embodiments. Based on the embodiments in the present disclosure, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present disclosure.

In the related art, the startup process of an application includes the following stages: start running, input/output (IO) request, sleep, and data readiness. All of these stages will take a certain amount of time. Among them, IO request means that when an application on a terminal device is started, the application needs to request some startup data from the kernel, and then proceed to the next step after receiving the data returned by the kernel.

However, when the application starts, the problem of blocking IO at startup often occurs. For example, when requesting interface data from the kernel, if the interface data is currently occupied by other programs and has not been released, the currently started application cannot quickly receive the interface data returned by the kernel, and the current application will always be in a waiting state and cannot proceed to the next step. Therefore, it may cause the IO request process to consume too much time. As a result, the application starts slowly and affects the user experience. For example, as shown in Figure 1, when the short video application is cold started, the running state (Running) accounts for 44.7%, the IO operation waiting state (IO Wait) accounts for 38.9%, the sleep state (Sleep) accounts for 11.7%, and the ready state (Runnable) accounts for 4%. It can be seen that when the application is started, IO blocking takes a long time, which greatly affects the startup speed of the application.

In response to this defect, the main idea of the technical solution provided by the embodiment of the present disclosure is: before the application is started, the IO operation data of the startup phase is collected in advance, and a pre-read file list is generated according to the IO operation data, the pre-read file list contains file information of files that the application needs to access in the IO operation of the startup phase, and the startup data required by the application in the startup phase is obtained according to the file information in the pre-read list, and the startup data is pre-read into the page cache memory. When the user clicks the application icon to start the application, the central processing unit (CPU) directly reads the startup data in the page cache memory, thereby avoiding the IO reading operation from the disk, solving the startup IO blocking problem, and reducing the time spent on the IO request process of the application in the startup phase, thereby improving the startup speed of the application.

FIG. 2 is an application scenario diagram of the application startup method provided in an embodiment of the present disclosure.

As shown in Figure 2, when the user wants to start an application, he performs a corresponding operation on the icon corresponding to the application (as shown in a in Figure 2), such as single-click, double-click, slide, long press, etc. The CPU of the device starts the application according to the relevant operations sensed by the user and enters the homepage of the application (as shown in b in Figure 2).

FIG3 is a flowchart diagram 1 of the application startup method provided in an embodiment of the present disclosure. The method provided in an embodiment of the present disclosure can be applied to various terminal devices such as mobile phones, tablets, wearable devices, and virtual reality devices.

As shown in FIG3 , the method provided by the embodiment of the present disclosure may include the following steps.

S301, receiving a start instruction input by a user for a target application.

Specifically, when the user wants to open the target application, he operates the display icon corresponding to the target application on the display screen of the device, where the operation may be but is not limited to single-click, double-click, slide, long press, hover touch, or any other operation that can start the target application.

S302, reading the startup data that the target application needs to access in the page cache memory according to the startup instruction, and starting the target application according to the startup data, wherein the startup data that the target application needs to access is the IO operation data of the target application in the startup phase collected in advance and stored in the page cache memory.

Specifically, the IO operation data of the target application in the startup phase is collected in advance, and the IO operation data is pre-read into the page cache memory. The CPU of the device detects the user's operation in real time, and when receiving the startup instruction of the target application, it directly reads the IO operation data in the page cache memory to start the target application.

In the disclosed embodiment, by pre-collecting the IO operation data of the target application in the startup phase and storing it in the page cache memory, when the user's startup instruction for the target application is received, the data that the target application needs to access is directly read from the page cache memory, avoiding direct reading of data from the disk when the application starts, solving the problem of startup blocking IO, and accelerating the startup speed of the application, thereby improving the user experience.

FIG4 is a second flow chart of the application startup method provided in an embodiment of the present disclosure. Based on the embodiment shown in FIG3 , this embodiment describes in detail the complete flow of the application startup method.

As shown in FIG. 4 , the method provided by the embodiment of the present disclosure may include the following steps.

S401, generating a pre-read file list according to the acquired IO operation data of at least one application in the startup phase, wherein the pre-read file list includes file information that the at least one application needs to access in the startup phase.

Specifically, the tracing tool ftrace can be used to collect IO operation data of the application during the startup phase.

In some embodiments, the IO operation data includes file information of files that need to be accessed by the IO operation of the application at the startup stage, and the file information includes file identifier (file name), file offset, and data length. Exemplarily, the IO operation data of the application at the startup stage collected by the tracking tool may be:

Tracing_mark_write:B|31022|read:/app/com.ss.android.ugc.aweme-IUyTG1jJ4wEJCV_-PkexLQ==/oat/arm/base.odex, offset:606208, size:69632.

Among them, "/app/com.ss.android.ugc.aweme-IUyTG1jJ4wEJCV_-PkexLQ==/oat/arm/base.odex" in the IO operation data is the file name (file identifier); "odex" indicates that the file is an executable binary code file generated based on vdex; "offset" indicates the file offset; "size" indicates the data length. In the IO operation data, the file offset is 606208 bytes; the data length is 69632 bytes.

Specifically, file information such as file name, file offset, and data length are extracted from all IO operation data of the application during the startup phase, and then a pre-read file list is generated. The pre-read file list contains the file name, file offset, and data length that at least one application needs to access for all IO operations during the startup phase.

In some embodiments, the files that the application needs to access during the IO operation of the startup phase may include, in addition to the resource file apk in the above example, an executable binary file vdex, an executable binary code file odex generated based on vdex, an executable binary code file art generated based on art, and an oat file used by the virtual machine.

In one possible case of the embodiment of the present disclosure, the generated pre-read file list is shown in Table 1.

Table 1

In this embodiment, Table 1 only includes several types of file information corresponding to the IO operation data of an application at the startup stage, including five types of file information: apk, adex, odex, art, and oat. In specific implementation, the IO operation data of an application at the startup stage may correspond to more files, which are not specifically limited here. Moreover, for different applications, the IO operation data at their respective startup stages are also different.

S402: Acquire startup data corresponding to the at least one application according to the file information, and pre-read the startup data into the page cache memory.

The file information includes the file name, file offset and data length.

Specifically, the corresponding file is obtained by the file name; the starting position of the data to be read in the file is determined according to the file offset; starting from the starting position, the data of the data length is read, and the read data is loaded into the page cache memory.

For example, referring to Table 1, the resource file is obtained according to the file name "/app/com.ss.android.ugc.aweme-IUyTG1jJ4wEJCV_-PkexLQ==/oat/arm/base.apk", the file offset is 652397, and the data length is 12845. Assuming that the resource file contains 70000 bytes of data, the 652397th byte is used as the starting position, 12845 bytes of data are read, and the read data is stored in the page cache memory.

S403, reading the startup data that the target application needs to access from the page cache memory according to the received startup instruction of the target application, and starting the target application according to the startup data.

Specifically, the correspondence between each application and the startup data is also stored in the page cache memory in advance. When the startup instruction of the target application is received, the startup instruction is parsed to obtain the identifier of the target application, and then according to the correspondence between the application identifier and the startup data, the startup data corresponding to the identifier of the target application is read in the page cache memory.

In the disclosed embodiment, the IO operation data of the target application in the startup phase is collected in advance and a pre-read file list is generated based on the IO operation data. The pre-read file list is used to load the data corresponding to each type of file information in the list into a page cache memory in advance. When a startup instruction of the target application is received from the user, the data that the target application needs to access is directly read from the page cache memory, thereby avoiding direct reading of data from the disk when the application is started, solving the problem of startup blocking IO, and accelerating the startup speed of the application, thereby improving the user experience.

In order to have a clearer understanding of the present application, the generation of the pre-read list in the application startup method is described in detail below in combination with a specific application scenario.

Referring to FIG. 5 , in a possible embodiment, the generated pre-read file list does not distinguish between terminal devices, that is, at least one application in the method provided in the embodiment described in FIG. 4 is an application installed in multiple terminal devices, and ultimately a pre-read file list is generated, which includes file information that all applications installed in multiple terminal devices need to access during IO operations in the startup phase, so that the pre-read file list can be used universally in multiple terminal devices.

Specifically, the IO operation data of each application in each terminal device during the startup phase is obtained, the IO operation data of all applications in each terminal device during the startup phase are aggregated, and the IO operation data corresponding to the duplicate applications in multiple terminal devices are deleted, and finally a pre-read file list common to multiple terminal devices is generated, and the pre-read file list is stored in the memory of multiple terminal devices.

Exemplarily, as shown in FIG5 , it is assumed that application A, application B, and application C are installed in terminal device 1; application C and application D are installed in terminal device 2; and application D and application E are installed in terminal device 3. Then the IO operation data corresponding to application C in terminal device 1 and application C in terminal device 2 are repeated, and the IO operation data of application C in the startup phase is deleted. Similarly, the IO operation data of application D in the startup phase is deleted. The specific information in the final generated pre-read file list is shown in Table 2, which contains the IO operation data of application A, application B, application C, application D, and application E in the startup phase.

Table 2

It should be noted that, for the sake of ease of description, the file types that need to be accessed by each application in the IO operation of the startup phase in Table 2 provided in this embodiment only list two types, apk and oat. However, in the specific implementation, it may also include several other file types as shown in Table 1, which are not listed one by one here.

Furthermore, after generating a pre-read file list common to multiple terminal devices, the pre-read file list is stored in the memory of each terminal device. Each terminal device obtains the startup data that the installed application needs to access during the IO operation of the startup phase based on the file information contained in the pre-read file list, and stores the startup data in the page cache memory of the terminal device.

In this embodiment, the generated pre-read file list can be used in multiple terminal devices. Only one terminal device needs to generate the pre-read file list, and other terminal devices can directly use the pre-read file list. Although the universality is improved to a certain extent, the degree of personalization is low. The pre-read file list may contain file information that needs to be accessed during the startup phase of the application installed in the terminal device. In addition, since the file information included in the pre-read file list is applicable to multiple terminal devices, the file information included in the pre-read file list is also large, which occupies a large storage space of the terminal device. The terminal device needs to retrieve the file information that needs to be accessed during the startup phase of the application to be started from a large amount of file information, which consumes a relatively long time.

In another possible embodiment, a personalized pre-read file list can also be generated for different terminal devices, that is, at least one application in the method provided in the embodiment described in Figure 4 is an application installed in a terminal device, and ultimately each terminal device corresponds to a pre-read file list, which contains file information that needs to be accessed by at least one application installed in the corresponding terminal device during the IO operation in the startup phase.

Exemplarily, as shown in FIG6a, application A, application B and application C are installed in terminal device 1, and terminal device 1 obtains IO operation data of these three applications in the startup phase, and generates a pre-read file list corresponding to terminal device 1 according to the IO operation data, and the pre-read file list includes file information that each of application A, application B and application C needs to access in the IO operation in the startup phase. According to the file information corresponding to each application in the pre-read file list, the startup data required by each application in the startup phase is obtained, and the startup data is stored in the page cache memory of terminal device 1. When the user clicks any one of application A, application B and application C installed in terminal device 1, the corresponding startup data is directly read in the page cache memory.

Similarly, as shown in FIG6b, the terminal device 2 has application C and application D installed, and the corresponding pre-read file list generated by the terminal device 2 includes file information that the application C and application D need to access in the IO operation of the startup phase.

In this embodiment, a corresponding pre-read file list is generated for different terminal devices in a personalized manner. Through the pre-read file list, the startup data of the application during the startup phase is pre-loaded into the page cache memory, which can not only ensure the startup speed of the application, but also reduce the storage space occupied by the pre-read file list.

In one possible case of this embodiment, multiple pre-read file lists can also be generated for different applications in each terminal device, and each pre-read file list contains file information that an application needs to access during the startup phase. Exemplarily, as shown in FIG6c, application A, application B, and application C in terminal device 1 correspond to three pre-read file lists respectively. In this embodiment, by generating different pre-read file lists for different applications in the terminal device in a personalized manner, it is avoided that the terminal device searches for file information corresponding to the application to be started in a large amount of file information corresponding to multiple applications included in the pre-read file list, and the speed is further improved.

In some embodiments, among the applications installed in the terminal device, some applications are frequently used by users, while some applications are not frequently used; the time consumed by IO operations in the startup phase of some applications is relatively high relative to the time consumed in the entire startup process (i.e., the IO blocking problem is more serious), while the time consumed by IO operations in the startup phase of some applications is relatively low relative to the time consumed in the entire startup process (i.e., the IO blocking problem in the startup phase is less). Therefore, in specific implementation, it is not necessary to pre-read the IO operation data of all applications installed in the terminal device in the startup phase into the page cache memory, and the IO operation data of some applications in the startup phase can be pre-read into the page cache memory according to the user's usage habits of the applications or the characteristics of the IO operations of the applications in the startup phase.

Specifically, determine the proportion of time taken by each application in the terminal device to perform input/output operations during the startup phase relative to the time taken during the startup phase; based on the time proportion, obtain the input/output operation data of at least one application during the startup phase, and the at least one application is an application corresponding to the time proportion being greater than a preset threshold.

The preset threshold value may be determined according to actual conditions, for example, the preset threshold value may be set to 40%.

For example, suppose that among the three applications (applications A, B and C) installed in the terminal device 1, the entire startup phase of application A takes 0.1 seconds, of which the IO operation state of the startup phase takes 0.05 seconds, then the IO operation waiting state of application A in the startup phase accounts for 50% of the duration of the entire startup phase; the startup phase of application B takes 0.2 seconds, and the IO operation waiting state of the startup phase takes 0.05 seconds, then the IO operation waiting state of application B in the startup phase accounts for 25%; the startup phase of application C takes 0.08 seconds, and the IO operation waiting state takes 0.035 seconds, then the IO operation waiting time of application C in the startup phase accounts for 43.75%. The IO operation state duration of applications A and C in the startup phase accounts for more than 40%, indicating that the IO blocking problem of applications A and C in the startup phase is more serious. Therefore, only the startup data of application programs A and C in the startup phase can be preloaded into the page cache memory, and application program B does not need to preload its startup data because the IO blocking problem in the startup phase is relatively small. That is, the IO operation data of application programs A and C in the startup phase are extracted to generate a pre-read file list corresponding to application programs A and C, or to generate respective pre-read file lists for the two applications.

It should be noted that the above preset threshold is not limited to 40%, and other values may be set according to the requirements for the application startup speed, such as 30%, 50%, etc.

In the disclosed embodiment, a personalized pre-read file list is generated based on the proportion of the time consumed by the IO operation waiting state of different applications in the terminal device during the startup phase relative to the duration of the entire startup phase. This not only solves the startup problem of applications with serious IO blocking problems, but also reduces the storage space occupied by the pre-read file list.

In another possible case of this embodiment, a pre-read file list may also be generated based on the user's usage habits of the applications in the terminal device. Specifically, it includes: obtaining user behavior information, the user behavior information includes the number of times the user uses each application in the terminal device and the length of time the application is used; according to the user behavior information, obtaining input/output operation data of at least one application in the startup phase, the at least one application being an application corresponding to a number of uses greater than a preset number threshold and/or a length of use greater than a preset length threshold.

Specifically, the CPU of the terminal device records the number of times each application is started and the running time. If the number of times an application is started is greater than a preset number threshold or the running time is greater than a preset time threshold, it means that the user uses the application frequently. A pre-read file list can be generated only for the applications that the user uses frequently. According to the pre-read file list, the startup data that the frequently used applications need to access during the startup phase is pre-loaded into the page cache memory. For other applications, which are rarely used by users, it is not necessary to pre-load their startup data during the startup phase.

For example, it is assumed that the preset number threshold is 50 and the preset duration threshold is 10 hours. Among the three applications (applications A, B and C) installed in the terminal device 1, it is assumed that the number of startups of application A is 60 times, and the total running time is 8 hours; the number of startups of application B is 45 times, and the total running time is 12 hours; the number of startups of application C is 20 times, and the total running time is 1 hour. This means that applications A and B are commonly used applications of the user. Therefore, it is necessary to obtain the IO operation data of applications A and B in the startup phase, generate one or two pre-read file lists, and finally pre-load the startup data that applications A and B need to access in the IO operation of the startup phase into the page cache memory according to the pre-read list.

In the embodiments of the present disclosure, by generating a personalized pre-read file list that conforms to the user's behavior habits based on the user's application usage habits, the user's personalized needs for application startup speed can be met. At the same time, there is no need to load all data that need to be accessed by all applications in the terminal device in the IO operation during the startup phase into the page cache memory, thereby reducing the occupation of space resources.

In a possible embodiment, the application startup method further includes: determining an application program that needs to be updated among the at least one application program; and updating a corresponding pre-read file list after the application program that needs to be updated is updated.

Specifically, when an application is updated, the pre-read file list may have inaccurate data due to changes in the application. In addition, the dexopt service can optimize installed applications. Once an application is optimized, the IO operation data of the application during the startup phase may also change. Therefore, the pre-read file list needs to be updated to ensure that the updated or optimized application can start normally and quickly.

In one possible case of this embodiment, the method for updating the corresponding pre-read file list may include: obtaining update information of the application that needs to be updated, the update information including newly added input/output operation data, modified input/output operation data and/or input/output operation data that needs to be deleted; writing the file information corresponding to the newly added input/input operation data into the pre-read file list; and/or, modifying the corresponding file information in the pre-read file list according to the modified input/output operation data; and/or, deleting the file information in the pre-read file list corresponding to the input/output operation data that needs to be deleted.

Exemplarily, as shown in Table 1 in the above embodiment, the pre-read file list contains file information of three types of files, namely, apk, vdex, odex, art and oat, which the application needs to access in the IO operation of the startup phase. If the IO operation data in the startup phase is modified after the application is updated, and the modified IO operation data is: Tracing_mark_write:B|31022|read:/app/com.ss.android.ugc.aweme-IUyTG1jJ4wEJCV_-PkexLQ==/oat/arm/base.odex, offset:123456, size:54321, then according to the modified IO operation data, the file offset corresponding to the corresponding odex file in Table 1 needs to be changed from "606208" to "123456", and the data length needs to be changed from "69632" to "54321". Similarly, if the application is updated and some input/output operation data is added or some input/output operation data is deleted, then the file information is added or the corresponding file information is deleted in the pre-read file list.

In some embodiments, if the terminal device originally has only one pre-read file list, that is, the file information corresponding to the applications installed in the terminal device is recorded in the pre-read file list, then for the updated application, the terminal device can also delete all the file information corresponding to the application in the pre-read file list before the application is updated, and then re-write the corresponding file information into the pre-read file list according to the IO operation data of the updated application in the startup phase. If each application in the terminal device corresponds to a pre-read file list, then for the updated application, the terminal device can delete the pre-read file list corresponding to the application before the application is updated, and then regenerate a pre-read file list according to the IO operation data of the updated application in the startup phase.

It should be noted that, in this embodiment, the pre-read file list may be updated when the corresponding updated application and the terminal device are in an idle state.

In the disclosed embodiment, by updating the pre-read file list when the device and the application are idle, more CPU resources will not be occupied when the application and the device are running, and the application can be guaranteed to start normally and quickly the next time the application is started.

In another possible case of the embodiment of the present disclosure, the method for starting an application further includes: determining a newly installed application; and updating a pre-read file list according to input/output operation data of the newly installed application during the startup phase.

Specifically, when using a terminal device, a user may install a new application. For the newly installed application, the original pre-read file list does not contain the file information of the file that needs to be accessed in the IO operation of the startup phase. Therefore, it is necessary to obtain the input/output operation data of the newly installed application in the startup phase, and then extract the file information in the input/output operation data of the newly installed application in the startup phase; and then update the pre-read file list according to the extracted file information.

If the terminal device has only one pre-read file list, that is, the file information corresponding to the applications installed in the terminal device are all recorded in the pre-read file list, then the file information extracted from the IO operation data of the newly installed application during the startup phase is written into the pre-read file list.

For example, assume that two applications A and B are originally installed in the terminal device, and their corresponding pre-read file lists are shown in Table 3-1. If application C is newly installed, the file information extracted from the IO operation data of the newly installed application C in the startup phase is written into the pre-read file list, and the updated pre-read file list is shown in Table 3-2.

Table 3-1

Table 3-2

If each application in the terminal device corresponds to a pre-read file list, a new pre-read file list is generated for the file information extracted from the IO operation data of the newly installed application in the startup phase. For example, if applications A and B are originally installed in the terminal device, application A corresponds to the first pre-read file list, and application B corresponds to the second pre-read file list, then a third pre-read file list is generated for the newly installed application C, and the third pre-read file list contains the file information that the newly installed application C needs to access in the IO operation of the startup phase.

In the disclosed embodiment, by updating the pre-read file list according to the newly installed application, the startup speed of the startup application during subsequent startup is guaranteed.

FIG. 7 is a schematic diagram of the structure of an application startup system provided in an embodiment of the present disclosure.

As shown in FIG7 , the system provided by the embodiment of the present disclosure includes: a receiving module 701 and a starting module 702; wherein the receiving module 701 is used to receive a starting instruction input by a user for a target application; the starting module 702 is used to read starting data that the target application needs to access in a page cache memory according to the starting instruction, and start the target application according to the starting data, wherein the starting data that the target application needs to access is input/output operation data of the target application in the starting phase collected in advance and stored in the page cache memory.

Furthermore, the system provided by the embodiment of the present disclosure also includes: a list generation module 703 and a pre-reading module 704; the list generation module is used to: generate a pre-read file list based on the input/output operation data of at least one application obtained during the startup phase, and the pre-read file list contains file information that the at least one application needs to access during the startup phase; the pre-reading module is used to obtain the startup data corresponding to the at least one application based on the file information, and pre-read the startup data into the page cache memory; wherein the at least one application is an application installed in one or more terminal devices.

Furthermore, the list generation module is specifically used to: generate a pre-read file list, wherein the pre-read file list contains file information that all applications need to access during the startup phase; or generate multiple pre-read file lists, each pre-read file list contains file information that an application needs to access during the startup phase.

Furthermore, the file information includes a file identifier, a file offset and a data length. Referring to FIG8 , the pre-reading module 704 includes: an acquisition unit 7041, for acquiring the file corresponding to the file identifier; a determination unit 7042, for determining the starting position of the startup data in the file according to the file offset; and a reading unit 7043, for reading the startup data of the data length starting from the starting position, and loading the read startup data into the page cache memory.

Furthermore, the startup module is specifically used to read the startup data corresponding to the identifier of the target application in the page cache memory according to the corresponding relationship between the application identifier and the startup data pre-stored in the page cache memory.

Furthermore, the system provided by the embodiment of the present disclosure also includes: an acquisition module 705, which is used to determine the proportion of time occupied by each application in the terminal device for input/output operations in the startup phase relative to the time taken in the startup phase; based on the time proportion, obtain input/output operation data of at least one application in the startup phase, and the at least one application is an application corresponding to the time proportion being greater than a preset threshold.

In some embodiments, the acquisition module is also used to: obtain user behavior information, the user behavior information including the number of times and duration of use of each application in the terminal device by the user; and obtain input/output operation data of at least one application during the startup phase based on the user behavior information, the at least one application being an application corresponding to a number of uses greater than a preset number threshold and/or a usage duration greater than a preset duration threshold.

Furthermore, the system provided by the embodiment of the present disclosure also includes: an update module 706, which is used to determine an application program that needs to be updated among the at least one application program; after the application program that needs to be updated is updated, update the corresponding pre-read file list.

Furthermore, the update module 706 is specifically used to: obtain update information of the application that needs to be updated, the update information including newly added input/output operation data, modified input/output operation data and/or input/output operation data that needs to be deleted; write the file information corresponding to the newly added input/input operation data into the pre-read file list; and/or, according to the modified input/output operation data, modify the corresponding file information in the pre-read file list; and/or, delete the file information in the pre-read file list corresponding to the input/output operation data that needs to be deleted.

In some embodiments, the update module is further used to: determine a newly installed application; and update the pre-read file list according to input/output operation data of the newly installed application during the startup phase.

Furthermore, the update module is specifically used to: extract file information from input/output operation data of the newly installed application in the startup phase; and write the extracted file information into the pre-read file list.

Furthermore, the list generation module is also used to: extract file information from the input/output operation data of the newly installed application in the startup phase; and generate a new pre-read file list according to the extracted file information.

The system provided in this embodiment can be used to execute the technical solution of the above method embodiment. Its implementation principle and technical effects are similar and will not be described in detail in this embodiment.

Referring to FIG9 , it shows a schematic diagram of the structure of an electronic device 900 suitable for implementing an embodiment of the present disclosure, and the electronic device 900 may be a terminal device or a server. The terminal device may include, but is not limited to, mobile terminals such as mobile phones, laptop computers, digital broadcast receivers, personal digital assistants (PDAs), tablet computers (Portable Android Devices, PADs), portable multimedia players (Portable Media Players, PMPs), vehicle-mounted terminals (such as vehicle-mounted navigation terminals), etc., and fixed terminals such as digital TVs, desktop computers, etc. The electronic device shown in FIG9 is only an example and should not impose any limitations on the functions and scope of use of the embodiments of the present disclosure.

As shown in FIG9 , the electronic device 900 may include a processing device (e.g., a central processing unit, a graphics processing unit, etc.) 901, which can perform various appropriate actions and processes according to a program stored in a read-only memory (ROM) 902 or a program loaded from a storage device 908 to a random access memory (RAM) 903. Various programs and data required for the operation of the electronic device 900 are also stored in the RAM 903. The processing device 901, the ROM 902, and the RAM 903 are connected to each other via a bus 904. An input/output (I/O) interface 905 is also connected to the bus 904.

Typically, the following devices may be connected to the I/O interface 905: input devices 906 including, for example, a touch screen, a touchpad, a keyboard, a mouse, a camera, a microphone, an accelerometer, a gyroscope, etc.; output devices 907 including, for example, a liquid crystal display (LCD), a speaker, a vibrator, etc.; storage devices 908 including, for example, a magnetic tape, a hard disk, etc.; and communication devices 909. The communication device 909 may allow the electronic device 900 to communicate wirelessly or wired with other devices to exchange data. Although FIG. 9 shows an electronic device 900 with various devices, it should be understood that it is not required to implement or have all the devices shown. More or fewer devices may be implemented or have alternatively.

In particular, according to an embodiment of the present disclosure, the process described above with reference to the flowchart can be implemented as a computer software program. For example, an embodiment of the present disclosure includes a computer program product, which includes a computer program carried on a computer-readable medium, and the computer program contains program code for executing the method shown in the flowchart. In such an embodiment, the computer program can be downloaded and installed from the network through the communication device 909, or installed from the storage device 908, or installed from the ROM 902. When the computer program is executed by the processing device 901, the above-mentioned functions defined in the method of the embodiment of the present disclosure are executed.

It should be noted that the computer-readable medium disclosed above may be a computer-readable signal medium or a computer-readable storage medium or any combination of the above two. The computer-readable storage medium may be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, device or device, or any combination of the above. More specific examples of computer-readable storage media may include, but are not limited to: an electrical connection with one or more wires, a portable computer disk, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the above. In the present disclosure, a computer-readable storage medium may be any tangible medium containing or storing a program that may be used by or in combination with an instruction execution system, device or device. In the present disclosure, a computer-readable signal medium may include a data signal propagated in a baseband or as part of a carrier wave, in which a computer-readable program code is carried. This propagated data signal may take a variety of forms, including but not limited to an electromagnetic signal, an optical signal, or any suitable combination of the above. The computer readable signal medium may also be any computer readable medium other than a computer readable storage medium, which may send, propagate or transmit a program for use by or in conjunction with an instruction execution system, apparatus or device. The program code contained on the computer readable medium may be transmitted using any suitable medium, including but not limited to: wires, optical cables, RF (radio frequency), etc., or any suitable combination of the above.

The computer-readable medium may be included in the electronic device, or may exist independently without being installed in the electronic device.

The computer-readable medium carries one or more programs. When the one or more programs are executed by the electronic device, the electronic device executes the method shown in the above embodiment.

Computer program code for performing the operations of the present disclosure may be written in one or more programming languages or a combination thereof, including object-oriented programming languages, such as Java, Smalltalk, C++, and conventional procedural programming languages, such as "C" or similar programming languages. The program code may be executed entirely on the user's computer, partially on the user's computer, as an independent software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In the case of a remote computer, the remote computer may be connected to the user's computer via any type of network, including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computer (e.g., via the Internet using an Internet service provider).

The flow chart and block diagram in the accompanying drawings illustrate the possible architecture, function and operation of the system, method and computer program product according to various embodiments of the present disclosure. In this regard, each square box in the flow chart or block diagram can represent a module, a program segment or a part of a code, and the module, the program segment or a part of the code contains one or more executable instructions for realizing the specified logical function. It should also be noted that in some implementations as replacements, the functions marked in the square box can also occur in a sequence different from that marked in the accompanying drawings. For example, two square boxes represented in succession can actually be executed substantially in parallel, and they can sometimes be executed in the opposite order, depending on the functions involved. It should also be noted that each square box in the block diagram and/or flow chart, and the combination of the square boxes in the block diagram and/or flow chart can be implemented with a dedicated hardware-based system that performs a specified function or operation, or can be implemented with a combination of dedicated hardware and computer instructions.

The units involved in the embodiments described in the present disclosure may be implemented by software or hardware. The name of a unit does not limit the unit itself in some cases. For example, the first acquisition unit may also be described as a "unit for acquiring at least two Internet Protocol addresses".

The functions described above herein may be performed at least in part by one or more hardware logic components. For example, without limitation, exemplary types of hardware logic components that may be used include: field programmable gate arrays (FPGAs), application specific integrated circuits (ASICs), application specific standard products (ASSPs), systems on chip (SOCs), complex programmable logic devices (CPLDs), and the like.

In the context of the present disclosure, a machine-readable medium may be a tangible medium that may contain or store a program for use by or in conjunction with an instruction execution system, device, or equipment. A machine-readable medium may be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium may include, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, device, or equipment, or any suitable combination of the foregoing. A more specific example of a machine-readable storage medium may include an electrical connection based on one or more lines, a portable computer disk, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.

In a first aspect, according to one or more embodiments of the present disclosure, a method for starting an application is provided, comprising:

Receiving a start instruction input by a user for a target application;

The startup data that the target application needs to access is read from the page cache memory according to the startup instruction, and the target application is started according to the startup data. The startup data that the target application needs to access is the input/output operation data of the target application in the startup phase collected in advance and stored in the page cache memory.

According to one or more embodiments of the present disclosure, before receiving a start instruction input by a user for a target application, the method further includes:

Generate a pre-read file list according to the acquired input/output operation data of at least one application in the startup phase, wherein the pre-read file list includes file information that the at least one application needs to access in the startup phase;

Acquire startup data corresponding to the at least one application according to the file information, and pre-read the startup data into the page cache memory;

The at least one application is an application installed in one or more terminal devices.

According to one or more embodiments of the present disclosure, the generating of the pre-read file list, wherein the pre-read file list contains file information that the at least one application needs to access during the startup phase, includes:

Generate a pre-read file list, wherein the pre-read file list contains all file information that the application needs to access during the startup phase;

or,

Generate multiple pre-read file lists, each of which contains file information that an application needs to access during a startup phase.

According to one or more embodiments of the present disclosure, the file information includes a file identifier, a file offset, and a data length, and obtaining startup data corresponding to the at least one application according to the file information, and pre-reading the startup data into the page cache memory includes:

Obtain the file corresponding to the file identifier;

Determine the starting position of the startup data in the file according to the file offset;

Starting from the start position, the startup data of the data length is read, and the read startup data is loaded into the page cache memory.

According to one or more embodiments of the present disclosure, the startup instruction includes an identifier of the target application, and reading startup data that the target application needs to access in a page cache memory according to the startup instruction includes:

The startup data corresponding to the identifier of the target application is read from the page cache memory according to the corresponding relationship between the application identifier and the startup data pre-stored in the page cache memory.

According to one or more embodiments of the present disclosure, the method further includes:

Determine the time taken by each application in the terminal device to perform input/output operations during the startup phase relative to the time taken during the startup phase;

According to the duration ratio, input/output operation data of at least one application in a startup phase is obtained, and the at least one application is an application corresponding to a duration ratio greater than a preset threshold.

According to one or more embodiments of the present disclosure, the method further includes:

Obtaining user behavior information, wherein the user behavior information includes the number of times and duration of use of each application in the terminal device by the user;

According to the user behavior information, input/output operation data of at least one application in the startup phase is obtained, and the at least one application is an application corresponding to a usage count greater than a preset threshold and/or a usage duration greater than a preset threshold.

According to one or more embodiments of the present disclosure, the method further includes:

determining an application program among the at least one application program that needs to be updated;

After the application program that needs to be updated is updated, the corresponding pre-read file list is updated.

According to one or more embodiments of the present disclosure, updating the corresponding pre-read file list includes:

Acquiring update information of the application program that needs to be updated, the update information including newly added input/output operation data, modified input/output operation data and/or input/output operation data that needs to be deleted;

Writing the file information corresponding to the newly added input/input operation data into the pre-read file list; and/or,

Modify the corresponding file information in the pre-read file list according to the modified input/output operation data; and/or,

The file information corresponding to the input/output operation data to be deleted in the pre-read file list is deleted.

According to one or more embodiments of the present disclosure, the method further includes:

Identify newly installed applications;

The pre-read file list is updated according to the input/output operation data of the newly installed application program in the startup phase.

According to one or more embodiments of the present disclosure, updating the pre-read file list according to the input/output operation data of the newly installed application in the startup phase includes:

Extracting file information from input/output operation data of the newly installed application during the startup phase;

The extracted file information is written into the pre-read file list.

According to one or more embodiments of the present disclosure, updating the pre-read file list according to the input/output operation data of the newly installed application in the startup phase includes:

Extracting file information from input/output operation data of the newly installed application during the startup phase;

Generate a new pre-read file list based on the extracted file information.

In a second aspect, according to one or more embodiments of the present disclosure, there is provided an application startup system, comprising: a receiving module and a startup module; wherein the receiving module is used to receive a startup instruction input by a user for a target application; the startup module is used to read startup data that the target application needs to access in a page cache memory according to the startup instruction, and start the target application according to the startup data, wherein the startup data that the target application needs to access is input/output operation data of the target application in the startup phase that is pre-collected and stored in the page cache memory.

According to one or more embodiments of the present disclosure, the system also includes: a list generation module and a pre-reading module; the list generation module is used to: generate a pre-read file list based on the input/output operation data of at least one application obtained during the startup phase, and the pre-read file list contains file information that the at least one application needs to access during the startup phase; the pre-reading module is used to obtain the startup data corresponding to the at least one application based on the file information, and pre-read the startup data into the page cache memory; wherein the at least one application is an application installed in one or more terminal devices.

According to one or more embodiments of the present disclosure, the list generation module is specifically used to: generate a pre-read file list, wherein the pre-read file list contains file information that all applications need to access during the startup phase; or generate multiple pre-read file lists, each pre-read file list contains file information that an application needs to access during the startup phase.

According to one or more embodiments of the present disclosure, the file information includes a file identifier, a file offset and a data length, and the pre-reading module includes: an acquisition unit, used to acquire the file corresponding to the file identifier; a determination unit, used to determine the starting position of the startup data in the file according to the file offset; and a reading unit, used to read the startup data of the data length starting from the starting position, and load the read startup data into the page cache memory.

According to one or more embodiments of the present disclosure, the startup module is specifically used to read the startup data corresponding to the identifier of the target application in the page cache memory according to the correspondence between the application identifier and the startup data pre-stored in the page cache memory.

According to one or more embodiments of the present disclosure, the system further includes: an acquisition module, used to determine the proportion of time occupied by each application in the terminal device for input/output operations during the startup phase relative to the time taken during the startup phase; based on the time proportion, obtaining input/output operation data of at least one application during the startup phase, the at least one application being an application corresponding to the time proportion being greater than a preset threshold.

According to one or more embodiments of the present disclosure, the acquisition module is also used to: obtain user behavior information, the user behavior information including the number of times and duration of use of each application in the terminal device by the user; based on the user behavior information, obtain input/output operation data of at least one application during the startup phase, the at least one application being an application corresponding to a number of uses greater than a preset number threshold and/or a usage duration greater than a preset duration threshold.

According to one or more embodiments of the present disclosure, the system further includes: an update module, configured to determine an application program that needs to be updated among the at least one application program; and to update a corresponding pre-read file list after the application program that needs to be updated is updated.

According to one or more embodiments of the present disclosure, the update module is specifically used to: obtain update information of the application that needs to be updated, the update information including newly added input/output operation data, modified input/output operation data and/or input/output operation data that needs to be deleted; write the file information corresponding to the newly added input/input operation data into the pre-read file list; and/or, based on the modified input/output operation data, modify the corresponding file information in the pre-read file list; and/or, delete the file information in the pre-read file list that corresponds to the input/output operation data that needs to be deleted.

According to one or more embodiments of the present disclosure, the update module is further used to: determine a newly installed application; and update the pre-read file list according to input/output operation data of the newly installed application during the startup phase.

According to one or more embodiments of the present disclosure, the update module is specifically used to: extract file information from input/output operation data of the newly installed application during the startup phase; and write the extracted file information into the pre-read file list.

According to one or more embodiments of the present disclosure, the list generation module is further used to: extract file information from input/output operation data of the newly installed application during the startup phase; and generate a new pre-read file list based on the extracted file information.

In a third aspect, according to one or more embodiments of the present disclosure, there is provided an electronic device, comprising: at least one processor and a memory;

The memory stores computer-executable instructions;

The at least one processor executes the computer-executable instructions stored in the memory, so that the at least one processor executes the application startup method described in the first aspect and various possible designs of the first aspect.

In a fourth aspect, according to one or more embodiments of the present disclosure, a computer-readable storage medium is provided, wherein the computer-readable storage medium stores computer execution instructions. When a processor executes the computer execution instructions, the application startup method described in the first aspect and various possible designs of the first aspect is implemented.

The above description is only a preferred embodiment of the present disclosure and an explanation of the technical principles used. Those skilled in the art should understand that the scope of disclosure involved in the present disclosure is not limited to the technical solutions formed by a specific combination of the above technical features, but should also cover other technical solutions formed by any combination of the above technical features or their equivalent features without departing from the above disclosed concept. For example, the above features are replaced with the technical features with similar functions disclosed in the present disclosure (but not limited to) by each other.

In addition, although each operation is described in a specific order, this should not be understood as requiring these operations to be performed in the specific order shown or in a sequential order. Under certain circumstances, multitasking and parallel processing may be advantageous. Similarly, although some specific implementation details are included in the above discussion, these should not be interpreted as limiting the scope of the present disclosure. Some features described in the context of a separate embodiment can also be implemented in a single embodiment in combination. On the contrary, the various features described in the context of a single embodiment can also be implemented in multiple embodiments individually or in any suitable sub-combination mode.

Although the subject matter has been described in language specific to structural features and/or methodological logical actions, it should be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or actions described above. On the contrary, the specific features and actions described above are merely example forms of implementing the claims.

Claims (12)

1. An application program starting method, comprising:

Receiving a starting instruction input by a user to a target application program;

Reading starting data which is required to be accessed by the target application program in a page cache according to the starting instruction, starting the target application program according to the starting data, wherein the starting data which is required to be accessed by the target application program is acquired in advance and is stored in the page cache;

before the receiving the start instruction input by the user to the target application program, the method further comprises the following steps:

Generating a pre-read file list according to the acquired input/output operation data of at least one application program in a starting stage, wherein the pre-read file list contains file information which needs to be accessed by the at least one application program in the starting stage;

acquiring starting data corresponding to the at least one application program according to the file information, and pre-reading the starting data into the page cache;

Wherein the at least one application is an application installed in one or more terminal devices;

Further comprises:

determining the time length occupation ratio of the time length occupied by each application program in the terminal equipment for input/output operation in the starting stage relative to the time length used in the starting stage;

And acquiring input/output operation data of at least one application program in a starting stage according to the duration ratio, wherein the at least one application program is an application program corresponding to the duration ratio being greater than a preset threshold value.

2. The method of claim 1, wherein the generating the pre-read file list containing file information that the at least one application needs to access during the startup phase comprises:

Generating a pre-read file list, wherein the pre-read file list contains file information which all application programs need to access in a starting stage;

Or alternatively

And generating a plurality of pre-read file lists, wherein each pre-read file list contains file information which is required to be accessed by an application program in a starting stage.

3. The method of claim 1, wherein the file information includes a file identifier, a file offset, and a data length, wherein the acquiring startup data corresponding to the at least one application program according to the file information, and pre-reading the startup data into the page cache, comprises:

acquiring a file corresponding to the file identifier;

determining the starting position of the starting data in the file according to the file offset;

Starting from the starting position, reading the starting data of the data length, and loading the read starting data into the page cache.

4. A method according to any of claims 1-3, wherein the launch instruction comprises an identification of the target application, the reading launch data in a page cache according to the launch instruction that the target application needs to access comprising:

And reading the starting data corresponding to the identification of the target application program in the page cache memory according to the corresponding relation between the application program identification and the starting data which are stored in the page cache memory in advance.

5. A method according to any one of claims 1-3, further comprising:

Determining an application program which needs to be updated in the at least one application program;

And after the application program needing to be updated is updated, updating the corresponding pre-read file list.

6. The method of claim 5, wherein updating the corresponding pre-read file list comprises:

acquiring update information of the application program to be updated, wherein the update information comprises newly added input/output operation data, modified input/output operation data and/or input/output operation data to be deleted;

Writing the file information corresponding to the newly added input/output operation data into the pre-read file list; and/or the number of the groups of groups,

Modifying corresponding file information in the pre-read file list according to the modified input/output operation data; and/or the number of the groups of groups,

And deleting file information corresponding to the input/output operation data to be deleted in the pre-read file list.

7. A method according to any one of claims 1-3, further comprising:

Determining a newly installed application;

and updating the pre-read file list according to the input/output operation data of the newly installed application program in the starting stage.

8. The method of claim 7, wherein updating the pre-read file list based on input/output operation data of the newly installed application at a start-up stage comprises:

extracting file information in input/output operation data of the newly installed application program in a starting stage;

and writing the extracted file information into the pre-read file list.

9. The method of claim 7, wherein updating the pre-read file list based on input/output operation data of the newly installed application at a start-up stage comprises:

extracting file information in input/output operation data of the newly installed application program in a starting stage;

And generating a new pre-read file list according to the extracted file information.

10. An application launch system comprising:

The receiving module is used for receiving a starting instruction input by a user to a target application program;

the starting module is used for reading starting data which is required to be accessed by the target application program in the page cache memory according to the starting instruction, starting the target application program according to the starting data, and acquiring input/output operation data of the target application program in a starting stage in advance and storing the input/output operation data in the page cache memory;

further comprises: a list generation module and a pre-reading module;

The list generation module is used for generating a pre-read file list according to the acquired input/output operation data of at least one application program in the starting stage, wherein the pre-read file list comprises file information which the at least one application program needs to access in the starting stage;

The pre-reading module is used for acquiring starting data corresponding to the at least one application program according to the file information and pre-reading the starting data into the page cache; wherein the at least one application is an application installed in one or more terminal devices;

Further comprises: the acquisition module is used for determining the time length occupation ratio of the time length occupied by each application program in the terminal equipment for input/output operation in the starting stage relative to the time length used in the starting stage; and acquiring input/output operation data of at least one application program in a starting stage according to the duration ratio, wherein the at least one application program is an application program corresponding to the duration ratio being greater than a preset threshold value.

11. An electronic device, comprising: at least one processor and memory;

The memory stores computer-executable instructions;

the at least one processor executing computer-executable instructions stored in the memory causes the at least one processor to perform the application launch method of any one of claims 1-9.

12. A computer readable storage medium having stored therein computer executable instructions which, when executed by a processor, implement the application launch method of any one of claims 1-9.