Application startup control method and device

Abstract

The present invention discloses a method and device for controlling the startup of an application, the method comprising: when receiving a running task analysis instruction, in the first startup process of the application, analyzing each running task of the application to obtain the task type corresponding to each running task; in the second startup process of the application, according to the task type corresponding to each running task, performing a matching running operation on each running task; judging whether all running tasks have been completed, and when the judgment result is yes, generating a startup completion instruction of the application. It can be seen that the implementation of the present invention can analyze the task type of each running task in the application, and then while the user is reading the compliance requirements, the time-consuming running tasks can be run in parallel, without having to execute all running tasks to complete the startup of the application after the user agrees, thereby shortening the startup time of the application and improving the startup efficiency and convenience of the application.

Description

Technical Field

[0001] The present invention relates to the field of computer technology, and in particular to a method and device for controlling the startup of an application program. Background Art

[0002] With the rise of mobile Internet, people are spending more and more time on mobile Internet. As one of the main carriers of mobile Internet, the convenience and security of mobile applications are increasingly attracting more attention.

[0003] At present, in the process of application startup, in order to ensure the security of their own privacy, people often hope to have more right to know, that is, they require that before the application is started, it can fully inform the user of the type of user privacy data that the application needs to obtain, and after the user agrees to the privacy data acquisition operation of the application, the application can continue to run the tasks required to be performed in the startup process, so that the application can complete the entire startup process. In this way, it is difficult to effectively shorten the startup time of the application, which is not conducive to improving the startup efficiency of the application, and thus cannot meet the convenience of the application required by the user. It can be seen that it is particularly important to provide a method to improve the startup efficiency of the application. Summary of the invention

[0004] The technical problem to be solved by the present invention is to provide a method and device for controlling the startup of an application, which can run non-privacy and time-consuming running tasks in parallel while the user reads the compliance requirements, which is conducive to shortening the startup time of the application and improving the startup efficiency and convenience of the application.

[0005] In order to solve the above technical problem, the first aspect of the present invention discloses a method for controlling the startup of an application program, the method comprising:

[0006] When receiving the running task analysis instruction of the application, according to the running task analysis instruction, in the first startup process of the application, analyzing at least one running task of the application to obtain a task type corresponding to each running task;

[0007] In the second startup process of the application, according to the task type corresponding to each running task, a matching running operation is performed on each running task;

[0008] It is determined whether all the running tasks are completed, and when it is determined that all the running tasks are completed, a second startup completion instruction of the application is generated.

[0009] As an optional implementation manner, in the first aspect of the present invention, analyzing at least one running task of the application to obtain a type corresponding to each running task includes:

[0010] Calculating the running time of at least one running task of the application;

[0011] For each of the running tasks, determining whether the running time of the running task is greater than or equal to a preset running time threshold;

[0012] When it is determined that the running time of the running task is greater than or equal to the preset running time threshold, determining that the running task is a first time-consuming running task;

[0013] When it is determined that the running time of the running task is less than the preset running time threshold, the running task is determined to be a non-time-consuming running task.

[0014] As an optional embodiment, in the first aspect of the present invention, the method further comprises:

[0015] After all the non-time-consuming running tasks are determined, a first degree of association between each of the non-time-consuming running tasks and the target privacy method set is calculated according to a predetermined target privacy method set;

[0016] Determine all non-time-consuming running tasks with a first degree of association greater than or equal to a preset first degree of association threshold with the target privacy method set as all privacy running tasks; all the privacy running tasks are running tasks used to collect the privacy data of the target user during the first startup process of the application;

[0017] The target privacy method set is determined in the following way:

[0018] Determine a privacy method set according to the determined privacy statement text; the privacy method set is a method set for collecting the private data of the target user; the privacy method set includes at least one privacy method;

[0019] When the application is not started, obtaining at least one target method of the application, where all the target methods are methods composed of programming files corresponding to the application;

[0020] According to the privacy method set, calculating a second degree of association between each of the target methods and the privacy method set;

[0021] All target methods whose second correlation degree with the privacy method set is greater than or equal to a preset second correlation degree threshold are determined as the target privacy method set; the target privacy method set is a method set that can collect the privacy data of the target user in the application.

[0022] As an optional embodiment, in the first aspect of the present invention, the method further comprises:

[0023] After all the privacy running tasks are determined, query the dynamic library corresponding to each of the privacy running tasks, and calculate the loading time of the dynamic library corresponding to each of the privacy running tasks;

[0024] For each dynamic library corresponding to the privacy running task, determine whether the loading time of the dynamic library is greater than or equal to a preset loading time threshold;

[0025] When it is determined that the loading time of the dynamic library is greater than or equal to the preset loading time threshold, the privacy running task is determined to be the second time-consuming running task.

[0026] As an optional embodiment, in the first aspect of the present invention, the method further comprises:

[0027] When it is determined that the loading time of the dynamic library is less than the preset loading time threshold, determining the privacy operation task as the target privacy operation task;

[0028] The performing of a matching operation on each of the running tasks according to the task type corresponding to each of the running tasks includes:

[0029] For each of the target privacy operation tasks, generating an operation request instruction matching the target privacy operation task according to the target privacy operation task, and outputting the operation request instruction; the operation request instruction is used to request the target user whether to agree to run the target privacy operation task;

[0030] Detecting whether a consent execution instruction corresponding to the target privacy execution task has been received;

[0031] When it is detected that the consent execution instruction has been received, the target privacy execution task is executed.

[0032] As an optional embodiment, in the first aspect of the present invention, the method further comprises:

[0033] Determine subthreads corresponding to all target time-consuming running tasks; all the target time-consuming running tasks include all the first time-consuming running tasks and all the second time-consuming running tasks;

[0034] Determine the running priority of each of the target time-consuming running tasks, and start running each of the target time-consuming running tasks according to the running priority of each of the target time-consuming running tasks among all the target time-consuming running tasks and the sub-thread corresponding to the target time-consuming running task; the higher the running priority of each of the target time-consuming running tasks, the earlier the execution order of the target time-consuming running task will be.

[0035] As an optional implementation, in the first aspect of the present invention, determining the running priority of each of the target time-consuming running tasks includes:

[0036] For each of the target time-consuming running tasks, determining the running priority of the target time-consuming running task according to the subordinate relationship between the target time-consuming running task and all the target time-consuming running tasks except the target time-consuming running task among all the target time-consuming running tasks; or,

[0037] Determine the weight corresponding to each of the target time-consuming running tasks according to the business needs of the target user; the weight corresponding to each of the target time-consuming running tasks represents the importance of the target time-consuming running task to the business needs of the target user;

[0038] The running priority of each target time-consuming running task is determined according to the weight corresponding to each target time-consuming running task; the higher the weight corresponding to each target time-consuming running task, the higher the running priority of the target time-consuming running task.

[0039] A second aspect of the present invention discloses a device for controlling the startup of an application program, the device comprising:

[0040] an analysis module, configured to, when receiving an operation task analysis instruction of the application, analyze at least one operation task of the application according to the operation task analysis instruction in a first startup process of the application to obtain a task type corresponding to each of the operation tasks;

[0041] A task running module, used for performing a matching running operation on each running task according to a task type corresponding to each running task during the second startup process of the application program;

[0042] The judging module is used to judge whether all the running tasks have been completed, and when it is judged that all the running tasks have been completed, generate a second startup completion instruction of the application.

[0043] As an optional implementation, in the second aspect of the present invention, the analysis module analyzes at least one running task of the application to obtain the type corresponding to each running task in the following manner:

[0044] Calculating the running time of at least one running task of the application;

[0045] For each of the running tasks, determining whether the running time of the running task is greater than or equal to a preset running time threshold;

[0046] When it is determined that the running time of the running task is greater than or equal to the preset running time threshold, determining that the running task is a first time-consuming running task;

[0047] When it is determined that the running time of the running task is less than the preset running time threshold, the running task is determined to be a non-time-consuming running task.

[0048] As an optional implementation, in the second aspect of the present invention, the device further includes:

[0049] A calculation module, configured to calculate a first degree of association between each of the non-time-consuming running tasks and the target privacy method set according to a predetermined target privacy method set after the analysis module determines all the non-time-consuming running tasks;

[0050] A determination module, used to determine all non-time-consuming running tasks with a first degree of association with the target privacy method set greater than or equal to a preset first degree of association threshold as all privacy running tasks; all the privacy running tasks are running tasks used to collect the privacy data of the target user during the first startup process of the application;

[0051] The target privacy method set is determined in the following way:

[0052] Determine a privacy method set according to the determined privacy statement text; the privacy method set is a method set for collecting the private data of the target user; the privacy method set includes at least one privacy method;

[0053] When the application is not started, obtaining at least one target method of the application, where all the target methods are methods composed of programming files corresponding to the application;

[0054] According to the privacy method set, calculating a second degree of association between each of the target methods and the privacy method set;

[0055] All target methods whose second correlation degree with the privacy method set is greater than or equal to a preset second correlation degree threshold are determined as the target privacy method set; the target privacy method set is a method set that can collect the privacy data of the target user in the application.

[0056] As an optional implementation, in the second aspect of the present invention, the calculation module is further used to query the dynamic library corresponding to each of the privacy running tasks after the analysis module determines all the privacy running tasks, and calculate the loading time of the dynamic library corresponding to each of the privacy running tasks;

[0057] The judgment module is further used to judge, for each dynamic library corresponding to the privacy running task, whether the loading time of the dynamic library is greater than or equal to a preset loading time threshold;

[0058] The determination module is further used to determine that the privacy running task is the second time-consuming running task when the judgment module determines that the loading time of the dynamic library is greater than or equal to the preset loading time threshold.

[0059] As an optional implementation, in the second aspect of the present invention, the determination module is further configured to determine that the privacy operation task is a target privacy operation task when the judgment module determines that the loading time of the dynamic library is less than the preset loading time threshold;

[0060] Wherein, the task running module includes:

[0061] An instruction processing submodule is used to generate, for each of the target privacy operation tasks, an operation request instruction matching the target privacy operation task according to the target privacy operation task, and output the operation request instruction; the operation request instruction is used to request the target user whether to agree to run the target privacy operation task;

[0062] A detection submodule, used to detect whether an approval operation instruction corresponding to the target privacy operation task has been received;

[0063] The task running submodule is used to run the target privacy running task when the detection submodule detects that the consent running instruction has been received.

[0064] As an optional implementation, in the second aspect of the present invention, the task execution module further includes:

[0065] A determination submodule, used to determine subthreads corresponding to all target time-consuming running tasks; all the target time-consuming running tasks include all the first time-consuming running tasks and all the second time-consuming running tasks;

[0066] The determination submodule is further used to determine the running priority of each of the target time-consuming running tasks;

[0067] The task running submodule is also used to start running each target time-consuming running task according to the running priority of each target time-consuming running task among all the target time-consuming running tasks and the sub-thread corresponding to the target time-consuming running task; the higher the running priority of each target time-consuming running task, the earlier the execution order of the target time-consuming running task will be.

[0068] As an optional implementation, in the second aspect of the present invention, the determination submodule determines the running priority of each of the target time-consuming running tasks in the following manner:

[0069] For each of the target time-consuming running tasks, determining the running priority of the target time-consuming running task according to the subordinate relationship between the target time-consuming running task and all the target time-consuming running tasks except the target time-consuming running task among all the target time-consuming running tasks; or,

[0070] Determine the weight corresponding to each of the target time-consuming running tasks according to the business needs of the target user; the weight corresponding to each of the target time-consuming running tasks represents the importance of the target time-consuming running task to the business needs of the target user;

[0071] The running priority of each target time-consuming running task is determined according to the weight corresponding to each target time-consuming running task; the higher the weight corresponding to each target time-consuming running task, the higher the running priority of the target time-consuming running task.

[0072] A third aspect of the present invention discloses another application startup control device, the device comprising:

[0073] A memory storing executable program code;

[0074] a processor coupled to the memory;

[0075] The processor calls the executable program code stored in the memory to execute the startup control method of the application disclosed in the first aspect of the present invention.

[0076] A fourth aspect of the present invention discloses a computer storable medium, wherein the computer storage medium stores computer instructions, and when the computer instructions are called, they are used to execute the startup control method of the application disclosed in the first aspect of the present invention.

[0077] Compared with the prior art, the embodiments of the present invention have the following beneficial effects:

[0078] In an embodiment of the present invention, when a running task analysis instruction of an application is received, according to the running task analysis instruction, in the first startup process of the application, at least one running task of the application is analyzed to obtain the task type corresponding to each running task; in the second startup process of the application, according to the task type corresponding to each running task, a matching running operation is performed on each running task; it is determined whether all running tasks have been completed, and when it is determined that all running tasks have been completed, a second startup completion instruction of the application is generated. It can be seen that the implementation of the present invention can run time-consuming running tasks in parallel while the user reads the compliance requirements, without the need to execute all running tasks in the application to complete the startup process of the application after the user agrees, thereby shortening the startup time of the application while ensuring the security of the user's privacy data, and improving the startup efficiency and convenience of the application, thereby improving the user's experience of using the application. BRIEF DESCRIPTION OF THE DRAWINGS

[0079] In order to more clearly illustrate the technical solutions in the embodiments of the present invention, the following briefly introduces the drawings required for use in the description of the embodiments. Obviously, the drawings described below are only some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without creative work.

[0080] Figure 1 It is a flowchart of a method for starting up an application program disclosed in an embodiment of the present invention;

[0081] Figure 2 It is a flow chart of another application startup control method disclosed in an embodiment of the present invention;

[0082] Figure 3 It is a structural schematic diagram of a startup control device for an application disclosed in an embodiment of the present invention;

[0083] Figure 4 It is a structural schematic diagram of another application startup control device disclosed in an embodiment of the present invention;

[0084] Figure 5 It is a structural schematic diagram of another application startup control device disclosed in an embodiment of the present invention. DETAILED DESCRIPTION

[0085] In order to enable those skilled in the art to better understand the scheme of the present invention, the technical scheme in the embodiments of the present invention will be clearly and completely described below in conjunction with the drawings in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present invention.

[0086] The terms "first", "second", etc. in the specification and claims of the present invention and the above-mentioned drawings are used to distinguish different objects rather than to describe a specific order. In addition, the terms "including" and "having" and any variations thereof are intended to cover non-exclusive inclusions. For example, a process, method, device, product or end including a series of steps or units is not limited to the listed steps or units, but may optionally include steps or units that are not listed, or may optionally include other steps or units inherent to these processes, methods, products or ends.

[0087] Reference to "embodiments" herein means that a particular feature, structure, or characteristic described in conjunction with the embodiments may be included in at least one embodiment of the present invention. The appearance of the phrase in various places in the specification does not necessarily refer to the same embodiment, nor is it an independent or alternative embodiment that is mutually exclusive with other embodiments. It is explicitly and implicitly understood by those skilled in the art that the embodiments described herein may be combined with other embodiments.

[0088] The present invention discloses a method and device for controlling the startup of an application program, which can analyze the task type of each running task in the application program, and then can run time-consuming running tasks in parallel while the user reads the compliance requirements, without having to execute all running tasks to complete the startup of the application program after the user agrees, thereby shortening the startup time of the application program and improving the startup efficiency and convenience of the application program. The following is a detailed description of each.

[0089] Embodiment 1

[0090] See also Figure 1 , Figure 1 1 is a flow chart of a method for controlling the startup of an application program disclosed in an embodiment of the present invention. Figure 1 The described application startup control method can be applied to the startup control of applications on mobile terminals, such as mobile phones, tablet devices, etc., and can also be applied to the startup control of applications on fixed terminals, such as desktop computers, etc., and the embodiments of the present invention do not limit this. Optionally, the method can be implemented by an application startup control system, and can also be implemented by an application startup control device. The application startup control device can be integrated in the application startup control device, and the embodiments of the present invention do not limit this. Figure 1 As shown, the startup control method of the application may include the following operations:

[0091] 101. When a running task analysis instruction of an application is received, according to the running task analysis instruction, in a first startup process of the application, at least one running task of the application is analyzed to obtain a task type corresponding to each running task.

[0092] In an embodiment of the present invention, optionally, the running task analysis instruction can be issued when it is necessary to troubleshoot the time-consuming running tasks of the application, and the running task analysis instruction can also be issued when it is necessary to optimize the startup process of the application. Specifically, a bytecode instrumentation tool can be used to find the time-consuming running tasks in the application, and the bytecode instrumentation tool can be used to collect all the running tasks of the application and the running time corresponding to each running task. Further, after receiving the running task analysis instruction, the programming files in the application can be bytecode instrumented first, and then the application is started, and during the startup process of the application, all the running tasks of the application and the running time corresponding to each running task are collected until the entire startup test process, that is, the first startup process, ends, and the collection results are output. Further optionally, according to the collection results, all the running tasks of the application are analyzed, and all the time-consuming running tasks and / or non-time-consuming running tasks can be determined. Furthermore, in the entire startup test process, all privacy running tasks and / or non-privacy non-time-consuming running tasks can be synchronously determined from all non-time-consuming running tasks, and all privacy non-time-consuming running tasks and / or privacy time-consuming running tasks can be determined from all privacy running tasks, among which time-consuming running tasks, non-time-consuming running tasks, privacy running tasks, privacy time-consuming running tasks, non-privacy non-time-consuming running tasks and privacy non-time-consuming running tasks can all be regarded as task types and can be stored as version records.

[0093] 102. In the second startup process of the application, according to the task type corresponding to each running task, a matching running operation is performed on each running task.

[0094] In an embodiment of the present invention, optionally, in the second startup process of the application, that is, the formal startup process, the version record obtained in the startup test closest in time can be used as the basis for the application to execute the running task, or the version record in the historical storage record can be used as the basis for the application to execute the running task according to specific business needs, and the running task of each task type of the application is matched with the running operation. For example, after determining the version record, in the formal startup process, based on the version record, the corresponding sub-thread can be immediately started to execute all time-consuming running tasks, and after obtaining the user's consent instruction, all non-time-consuming running tasks can be run in parallel; or, the corresponding sub-thread can be immediately started to execute all time-consuming running tasks and privacy time-consuming running tasks, and after obtaining the user's consent instruction, all privacy non-time-consuming running tasks can be run in parallel. Specifically, the non-privacy and non-time-consuming running tasks determined from the non-time-consuming running tasks can be executed after obtaining the user's consent instruction, or they can be executed without obtaining the user's consent instruction.

[0095] 103. Determine whether all running tasks have been completed. When it is determined that all running tasks have been completed, generate a second startup completion instruction of the application program.

[0096] In an embodiment of the present invention, optionally, after determining that all time-consuming tasks and all non-time-consuming tasks have been completed, a startup completion instruction for the application may be generated; or after determining that all time-consuming tasks, privacy time-consuming tasks, and privacy non-time-consuming tasks have been completed, a startup completion instruction for the application may be generated, and the embodiment of the present invention is not limited thereto.

[0097] It can be seen that the implementation of the embodiment of the present invention can perform matching running operations on running tasks of different task types in parallel after classifying all running tasks of the application by task type. In this way, there is no need to execute all running tasks after the user agrees to the privacy data collection operation of the application. This is beneficial for effectively shortening the startup time of the application while ensuring the privacy security of the user, thereby improving the startup efficiency and convenience of the application, thereby improving the user experience of the application and increasing the user stickiness of the application.

[0098] Embodiment 2

[0099] See also Figure 2 , Figure 2 1 is a flow chart of another application startup control method disclosed in an embodiment of the present invention. Figure 2The described application startup control method can be applied to the startup control of applications on mobile terminals, such as mobile phones, tablet devices, etc., and can also be applied to the startup control of applications on fixed terminals, such as desktop computers, etc., and the embodiments of the present invention do not limit this. Optionally, the method can be implemented by an application startup control system, and can also be implemented by an application startup control device. The application startup control device can be integrated in the application startup control device, and the embodiments of the present invention do not limit this. Figure 2 As shown, the startup control method of the application may include the following operations:

[0100] 201. When receiving an execution task analysis instruction of an application, calculate, according to the execution task analysis instruction, an execution time of at least one execution task of the application during a first startup process of the application.

[0101] In an embodiment of the present invention, the running time of all running tasks in the application can be collected by bytecode instrumentation. Specifically, the bytecode instrumentation can be implemented by aspect-oriented programming. Optionally, the bytecode instrumentation can insert a probe into the application on the basis of ensuring the original logical integrity of the application, collect information in the code (the method itself, method parameter values, return values, etc.) through the probe, and insert a code segment at a specific location, thereby collecting dynamic context information when the program is running.

[0102] 202. For each running task, determine whether the running time of the running task is greater than or equal to a preset running time threshold; when the judgment result of step 202 is yes, trigger the execution of step 203; when the judgment result of step 202 is no, trigger the execution of step 204.

[0103] In the embodiment of the present invention, optionally, a runtime threshold, such as 3 milliseconds, 5 milliseconds, etc., can be set according to specific business requirements to identify all time-consuming running tasks in the application, that is, running tasks that exceed the runtime threshold. Further, running tasks that do not exceed the runtime threshold can be represented as non-time-consuming running tasks.

[0104] 203. Determine that the running task is the first time-consuming running task.

[0105] In the embodiment of the present invention, optionally, when there is no subordinate relationship between the running tasks, the running time of the running tasks without the subordinate relationship can be tested in parallel; when there is a subordinate relationship between the running tasks, the running time of the running tasks can be tested in order according to the subordinate relationship. Further, according to the test results, when it is determined that the running task exceeds the running time threshold, it can be determined as the first time-consuming running task, that is, the time-consuming running task.

[0106] 204. Determine that the running task is a non-time-consuming running task.

[0107] In an embodiment of the present invention, similarly, the running time of the running task can be tested in parallel or in sequence, and when it is determined that the running task does not exceed the running time threshold, it can be determined as a non-time-consuming running task. Optionally, the non-time-consuming running task may include a non-time-consuming non-privacy running task and / or a privacy running task. Specifically, the privacy running task in the non-time-consuming running task can be determined by judging whether a method in the privacy method set is called during the test startup process of the application through the privacy method set collected when the application is not started.

[0108] 205. In the second startup process of the application, according to the task type corresponding to each running task, a matching running operation is performed on each running task.

[0109] 206. Determine whether all running tasks have been completed. When it is determined that all running tasks have been completed, generate a second startup completion instruction of the application program.

[0110] In the embodiment of the present invention, for other descriptions of step 205-step 206, please refer to the detailed description of step 105-step 106 in the first embodiment, and the embodiment of the present invention will not be repeated.

[0111] It can be seen that the implementation of the embodiment of the present invention can determine whether each running task in the application belongs to a time-consuming task type or a non-time-consuming task type by setting a time threshold in the startup process test. In this way, the task type corresponding to each running task can be determined reasonably and specifically, thereby improving the reliability and accuracy of the obtained task type results, which is facilitating the subsequent smooth matching of different task types and improving the operating efficiency of the application's running tasks.

[0112] In an optional embodiment, the method may further include:

[0113] After all non-time-consuming running tasks are determined, a first degree of association between each non-time-consuming running task and the target privacy method set is calculated according to a predetermined target privacy method set;

[0114] All non-time-consuming running tasks whose first correlation degree with the target privacy method set is greater than or equal to a preset first correlation degree threshold are determined as all privacy running tasks.

[0115] In this optional embodiment, optionally, non-time-consuming running tasks may include privacy running tasks and / or non-privacy non-time-consuming running tasks. Further, the privacy running tasks and / or non-privacy non-time-consuming running tasks can be determined by judging whether there are running tasks that meet the target privacy method set in the running tasks of the non-time-consuming running task type. Specifically, all privacy running tasks can be running tasks used to collect the privacy data of the target user in the startup process test of the application. For example, if the target privacy method set includes the first privacy method, the second privacy method and the third privacy method, and during the startup process test, the methods called involving the target privacy method set are only the first privacy method and the third privacy method, then the first privacy method and the third privacy method can be used as privacy running tasks in the startup process test. Further optionally, the privacy data of the target user can be geographic location information and / or chat records and / or photo videos and / or behavioral habit information related to the target user, etc., which is not limited in this optional embodiment.

[0116] Furthermore, the target privacy method set can be determined in the following manner: determine the privacy method set based on the determined privacy statement text; obtain at least one target method of the application when the application is not started; calculate the second correlation degree between each target method and the privacy method set based on the privacy method set; determine all target methods whose second correlation degree with the privacy method set is greater than or equal to a preset second correlation degree threshold as the target privacy method set.

[0117] Among them, the privacy statement text can be used to describe the way in which users are related to personal information collected through websites and applications. Specifically, based on the privacy statement text, the methods involved in general applications that can collect user privacy data, that is, a privacy method set, can be found, and the privacy method set can include multiple privacy methods. Further, based on the privacy method set, by scanning all target methods in the target application (methods composed of programming files corresponding to the application), the methods called by the target application that involve collecting user privacy data, that is, the target privacy method set, can be found. Further, the target privacy method set can be stored as a version record, and can be compared with other historical version records to find version differences. For example, if the current version of the target privacy method set is version 1.2.0, compared with the previous version 1.1.0, because the target application has added the function of uploading user avatars, it is necessary to access the user's album data, then the target privacy method set of version 1.2.0 will increase the methods related to accessing user album data. At this time, a version check instruction can be generated, thereby prompting relevant R&D personnel to check the current version 1.2.0 and the previous version 1.1.0 to troubleshoot problems.

[0118] It can be seen that this optional embodiment can be based on the target privacy method set to find out the methods involved in the target privacy method set that are called during the startup process test, and thus determine them as privacy running tasks. In this way, the running tasks related to collecting user privacy data can be determined based on evidence, which is beneficial to reasonably and effectively ensure the security of user privacy data when running privacy running tasks later, and improve the user experience when using the application.

[0119] In another optional embodiment, the method may further include:

[0120] After all privacy running tasks are determined, query the dynamic library corresponding to each privacy running task, and calculate the loading time of the dynamic library corresponding to each privacy running task;

[0121] For each dynamic library corresponding to the privacy running task, determine whether the loading time of the dynamic library is greater than or equal to the preset loading time threshold;

[0122] When it is determined that the loading time of the dynamic library is greater than or equal to the preset loading time threshold, the privacy running task is determined to be the second time-consuming running task.

[0123] In this optional embodiment, optionally, the loading time threshold of the dynamic library can be set to further determine whether the privacy operation task belongs to a non-time-consuming or time-consuming privacy operation task type, or the non-time-consuming and time-consuming privacy operation tasks can be determined by determining whether the privacy operation task needs to load the dynamic library. Specifically, when the privacy operation task is a non-time-consuming task type, it can be determined as a privacy non-time-consuming operation task, that is, the target privacy operation task; when the privacy operation task is a time-consuming task type, it can be determined as a non-privacy time-consuming operation task, that is, the second time-consuming operation task. For example, if you want to call a privacy operation method in a dynamic library, that is, a privacy operation task, you need to load the dynamic library first, and this loading process is relatively time-consuming; while directly accessing the privacy operation method of the dynamic library is not time-consuming, but according to the privacy statement text, it requires user consent before execution.

[0124] It can be seen that this optional embodiment can analyze the privacy running tasks and further filter out the time-consuming tasks in the privacy running tasks. This is conducive to further rationally planning the running modes of all time-consuming running tasks in the application, and then effectively utilizing the time during the application startup process, thereby improving the startup control efficiency of the application.

[0125] In yet another optional embodiment, the method may further include:

[0126] When it is determined that the loading time of the dynamic library is less than a preset loading time threshold, the privacy operation task is determined to be a target privacy operation task.

[0127] In this optional embodiment, similarly, the non-time-consuming task in the privacy operation task, i.e., the target privacy operation task (privacy non-time-consuming task), can be determined by setting a dynamic library loading time threshold or judging whether the dynamic library needs to be loaded. Specifically, after determining the target privacy operation task, according to the privacy statement text, during the formal startup of the application, the target privacy operation task needs to obtain the consent instruction sent by the user before executing the operation task.

[0128] It can be seen that this optional implementation example can also analyze the privacy running tasks, further filter out non-time-consuming tasks in the privacy running tasks, and set the privacy non-time-consuming tasks to be executed after the user agrees. In this way, the user can have the right to know about the collection of privacy data when using the application, which is conducive to ensuring the security of the user's privacy data and the compliance of the application when performing running tasks.

[0129] In yet another optional embodiment, the step 205 of performing a matching operation on each running task according to the task type corresponding to each running task may include:

[0130] For each target privacy operation task, generate an operation request instruction matching the target privacy operation task according to the target privacy operation task, and output the operation request instruction;

[0131] Detect whether the consent operation instruction corresponding to the target privacy operation task has been received;

[0132] When it is detected that an instruction to agree to run is received, the target privacy run task is run.

[0133] In this optional embodiment, specifically, the run request instruction can be used to request whether the target user agrees to run the target privacy run task. For example, when an application involves a target privacy run task that needs to collect user geographic location information, before running the target privacy run task, a run request instruction matching the target privacy run task needs to be generated and output to the user client, thereby requesting whether the target user agrees to the collection of geographic location information; when receiving the consent run instruction sent by the user client, the target privacy run task is run; when receiving the refusal run instruction sent by the user client, the target privacy run task is not executed, thereby terminating the startup operation of the application.

[0134] It can be seen that this optional embodiment can fully remind the user of the privacy data that the application needs to collect, and collect the privacy data after obtaining the user's consent. This is conducive to improving the security and privacy of user information, thereby improving the user's experience of using the application.

[0135] In yet another optional embodiment, the method may further include:

[0136] Determine the sub-threads corresponding to all target time-consuming running tasks;

[0137] Determine the running priority of each target time-consuming running task, and start running each target time-consuming running task according to the running priority of each target time-consuming running task among all target time-consuming running tasks and the sub-thread corresponding to the target time-consuming running task.

[0138] In this optional embodiment, optionally, all first time-consuming running tasks and all second time-consuming running tasks can be regarded as target time-consuming running tasks. Specifically, after determining all target time-consuming running tasks, before officially starting, the sub-threads corresponding to each target time-consuming running task can be determined. Further optionally, determining the sub-threads corresponding to all target time-consuming running tasks can include: determining the sub-threads corresponding to each target time-consuming running task according to the specific task type corresponding to each target time-consuming running task and / or the number of tasks of all target time-consuming running tasks. For example, if the number of target time-consuming running tasks is five, wherein the five target time-consuming running tasks include three specific task types, and each sub-thread can execute two target time-consuming running tasks of the same specific task type, then three sub-threads can be started to execute the five target time-consuming running tasks. Further, before or after determining the sub-thread corresponding to each target time-consuming running task, the running priority of each target time-consuming running task can be determined, and then the target time-consuming running task can be started and executed according to the running priority and sub-thread corresponding to the target time-consuming running task. For example, according to the priority of each target time-consuming task, the corresponding sub-threads can be started in parallel to run the target time-consuming tasks with the same priority, or the corresponding sub-threads can be started in sequence to run the target time-consuming tasks according to the priority. Similarly, in each sub-thread, each target time-consuming task on the sub-thread can also be run in sequence according to the priority. Specifically, the higher the running priority of each target time-consuming task, the higher the execution order of the target time-consuming task.

[0139] It can be seen that this optional embodiment can reasonably plan the execution order of each target time-consuming running task according to the priority size of each target time-consuming running task. In this way, during the startup process of the application, it can avoid the target time-consuming running task from having running chaos in the startup process, and the running tasks can be executed in an orderly manner, which greatly improves the startup time utilization of the application, thereby speeding up the startup and operation of the application.

[0140] In yet another optional embodiment, determining the running priority of each target time-consuming running task in the above step may include:

[0141] For each target time-consuming running task, the running priority of the target time-consuming running task is determined according to the subordinate relationship between the target time-consuming running task and all target time-consuming running tasks except the target time-consuming running task among all target time-consuming running tasks.

[0142] In this optional embodiment, the priority of the target time-consuming running task can be determined according to the subordinate relationship, that is, the dependency relationship, between the target time-consuming running task and other target time-consuming running tasks except the target time-consuming running task. For example, if the first target time-consuming running task depends on the second target time-consuming running task, and the second target time-consuming running task depends on the third target time-consuming running task, then the priorities are arranged from large to small as follows: the third target time-consuming running task, the second target time-consuming running task, and the first target time-consuming running task. The third target time-consuming running task is executed first, then the second target time-consuming running task is executed, and finally the first target time-consuming running task is executed.

[0143] It can be seen that this optional embodiment can determine the priority of each target time-consuming running task based on the subordinate relationship between the target time-consuming running tasks, which is conducive to improving the reliability and accuracy of the obtained priority results, thereby facilitating the orderly progress of all subsequent target time-consuming running tasks and ensuring the rapid startup of the application.

[0144] In yet another optional embodiment, determining the running priority of each target time-consuming running task in the above step may also include:

[0145] Determine the weight of each target time-consuming task based on the target user's business needs;

[0146] According to the weight corresponding to each target time-consuming running task, the running priority of each target time-consuming running task is determined.

[0147] In this optional embodiment, specifically, the weight corresponding to each target time-consuming running task represents the importance of the target time-consuming running task to the business needs of the target user, and the higher the weight corresponding to each target time-consuming running task, the higher the running priority of the target time-consuming running task. For example, running tasks related to screen rendering are generally relatively time-consuming. If the user needs to see the screen rendering effect as soon as possible, that is, the weight of the target time-consuming running task related to screen rendering is relatively high, the priority of the target time-consuming running task is also relatively high, so that it can be determined to execute the target time-consuming running task in advance.

[0148] It can be seen that this optional implementation example can determine the running priority of each target time-consuming running task according to the user's business needs, and then execute all target time-consuming running tasks in order, enriching the method of determining the running task priority, and can flexibly meet the different business needs of users, thereby improving the user experience and user stickiness of the application.

[0149] Embodiment 3

[0150] See also Figure 3 , Figure 3 Schematic diagram of a structure of a startup control device for an application disclosed in an embodiment of the present invention. Figure 3 As shown, the application's startup control device may include:

[0151] The analysis module 301 is used for, when receiving an operation task analysis instruction of the application, analyzing at least one operation task of the application in a first startup process of the application according to the operation task analysis instruction, to obtain a task type corresponding to each operation task;

[0152] The task running module 302 is used to perform a matching running operation on each running task according to the task type corresponding to each running task during the second startup process of the application program;

[0153] The judgment module 303 is used to judge whether all running tasks have been completed, and when it is judged that all running tasks have been completed, generate a second startup completion instruction of the application program.

[0154] It can be seen that implementation Figure 3The startup control device of the described application can classify all running tasks of the application by task type, and then perform matching running operations on running tasks of different task types in parallel. In this way, there is no need to execute all running tasks after the user agrees to the privacy data collection operation of the application. This is beneficial for effectively shortening the startup time of the application while ensuring the privacy security of the user, thereby improving the startup efficiency and convenience of the application, thereby improving the user experience of the application and increasing the user stickiness of the application.

[0155] In an optional embodiment, the analysis module 301 analyzes at least one running task of the application program to obtain the type corresponding to each running task in the following manner:

[0156] Calculate the running time of at least one running task of the application;

[0157] For each running task, determine whether the running time of the running task is greater than or equal to a preset running time threshold;

[0158] When it is determined that the running time of the running task is greater than or equal to the preset running time threshold, determining the running task as the first time-consuming running task;

[0159] When it is determined that the running time of the running task is less than the preset running time threshold, the running task is determined to be a non-time-consuming running task.

[0160] It can be seen that implementation Figure 4 The startup control device of the described application can determine whether each running task in the application belongs to a time-consuming task type or a non-time-consuming task type by setting a time threshold in the startup process test. In this way, the task type corresponding to each running task can be determined reasonably and specifically, thereby improving the reliability and accuracy of the obtained task type results, which is conducive to the subsequent smooth matching of different task types and improving the operating efficiency of the application's running tasks.

[0161] In another optional embodiment, the device may further include:

[0162] A calculation module 304 is used to calculate a first correlation degree between each non-time-consuming running task and a target privacy method set according to a predetermined target privacy method set after the analysis module 301 determines all non-time-consuming running tasks;

[0163] The determination module 305 is used to determine all non-time-consuming running tasks whose first correlation with the target privacy method set is greater than or equal to a preset first correlation threshold as all privacy running tasks; all privacy running tasks are running tasks used to collect the privacy data of the target user during the first startup process of the application.

[0164] In this optional embodiment, the target privacy method set is determined by:

[0165] Determine a privacy method set according to the determined privacy statement text; the privacy method set is a method set for collecting private data of the target user; the privacy method set includes at least one privacy method;

[0166] When the application is not started, obtaining at least one target method of the application, where all target methods are methods composed of programming files corresponding to the application;

[0167] According to the privacy method set, calculating the second correlation degree between each target method and the privacy method set;

[0168] All target methods whose second correlation degree with the privacy method set is greater than or equal to a preset second correlation degree threshold are determined as a target privacy method set; the target privacy method set is a method set that can collect the privacy data of the target user in the application.

[0169] It can be seen that implementation Figure 4 The startup control device of the described application can find out the methods involved in the target privacy method set that are called during the startup process test based on the target privacy method set, and thus determine them as privacy running tasks. In this way, the running tasks related to collecting user privacy data can be determined based on the basis, which is conducive to reasonably and effectively ensuring the security of user privacy data when running privacy running tasks in the future, and improving the user experience when using the application.

[0170] In another optional embodiment, the calculation module 304 is further used to query the dynamic library corresponding to each privacy operation task after the analysis module 301 determines all privacy operation tasks, and calculate the loading time of the dynamic library corresponding to each privacy operation task;

[0171] The judgment module 303 is further used to judge whether the loading time of the dynamic library corresponding to each privacy operation task is greater than or equal to a preset loading time threshold;

[0172] The determination module 305 is also used to determine that the privacy running task is the second time-consuming running task when the judgment module 303 determines that the loading time of the dynamic library is greater than or equal to the preset loading time threshold.

[0173] It can be seen that implementation Figure 4 The startup control device of the described application can analyze the privacy running tasks and further screen out the time-consuming tasks in the privacy running tasks. This is conducive to further rationally planning the running modes of all time-consuming running tasks in the application, and then effectively utilizing the time during the application startup process, thereby improving the startup control efficiency of the application.

[0174] In another optional embodiment, the determination module 305 is further used to determine that the privacy operation task is a target privacy operation task when the judgment module 303 determines that the loading time of the dynamic library is less than a preset loading time threshold.

[0175] It can be seen that implementation Figure 4 The startup control device of the described application can also analyze the privacy running tasks, further filter out non-time-consuming tasks in the privacy running tasks, and set the privacy non-time-consuming tasks to be executed after the user agrees. In this way, the user can have the right to know about the collection of privacy data when using the application, which is conducive to ensuring the security of the user's privacy data and the compliance of the application when performing running tasks.

[0176] In another optional embodiment, the task execution module 302 may include:

[0177] The instruction processing submodule 3021 is used to generate an operation request instruction matching the target privacy operation task according to the target privacy operation task for each target privacy operation task, and output the operation request instruction;

[0178] The detection submodule 3022 is used to detect whether the consent execution instruction corresponding to the target privacy execution task is received;

[0179] The task running submodule 3023 is used to run the target privacy running task when the detection submodule 3022 detects that an agreed running instruction has been received.

[0180] In this optional embodiment, the run request instruction is used to request whether the target user agrees to run the target privacy run task.

[0181] It can be seen that implementation Figure 4 The startup control device of the described application can fully remind the user of the privacy data that the application needs to collect, and collect the privacy data after obtaining the user's consent. This is conducive to improving the security and privacy of user information, thereby improving the user's experience of using the application.

[0182] In another optional embodiment, the task execution module 302 may further include:

[0183] A determination submodule 3024 is used to determine the subthreads corresponding to all target time-consuming running tasks;

[0184] The determination submodule 3024 is further used to determine the running priority of each target time-consuming running task;

[0185] The task running submodule 3023 is further used to start running each target time-consuming running task according to the running priority of each target time-consuming running task among all target time-consuming running tasks and the subthread corresponding to the target time-consuming running task.

[0186] In this optional embodiment, all target time-consuming running tasks include all first time-consuming running tasks and all second time-consuming running tasks; the higher the running priority of each target time-consuming running task, the earlier the execution order of the target time-consuming running task.

[0187] It can be seen that implementation Figure 4 The startup control device of the described application can reasonably plan the execution order of each target time-consuming running task according to the priority size of each target time-consuming running task. In this way, during the startup process of the application, it can avoid the target time-consuming running task from having running chaos in the startup process, and execute the running tasks in an orderly manner, which greatly improves the startup time utilization of the application, thereby speeding up the startup and operation of the application.

[0188] In another optional embodiment, the determination submodule 3024 determines the running priority of each target time-consuming running task in the following manner:

[0189] For each target time-consuming running task, the running priority of the target time-consuming running task is determined according to the subordinate relationship between the target time-consuming running task and all target time-consuming running tasks except the target time-consuming running task among all target time-consuming running tasks.

[0190] It can be seen that implementation Figure 4 The startup control device of the described application can determine the priority of each target time-consuming running task based on the subordinate relationship between the target time-consuming running tasks, which is conducive to improving the reliability and accuracy of the obtained priority results, thereby facilitating the orderly progress of all subsequent target time-consuming running tasks and ensuring the rapid startup of the application.

[0191] In another optional embodiment, the determination submodule 3024 may determine the running priority of each target time-consuming running task in the following manner:

[0192] Determine the weight of each target time-consuming task based on the target user's business needs;

[0193] According to the weight corresponding to each target time-consuming running task, the running priority of each target time-consuming running task is determined.

[0194] In this optional embodiment, the weight corresponding to each target time-consuming running task represents the importance of the target time-consuming running task to the business needs of the target user; the higher the weight corresponding to each target time-consuming running task, the higher the running priority of the target time-consuming running task.

[0195] It can be seen that implementation Figure 4 The startup control device of the described application can determine the running priority of each target time-consuming running task according to the user's business needs, and then execute all target time-consuming running tasks in order, enriching the method of determining the running task priority, and can flexibly meet the different business needs of users, thereby improving the user experience and user stickiness of the application.

[0196] Embodiment 4

[0197] See also Figure 5 , Figure 5 FIG. 1 is a schematic diagram of the structure of another application startup control device disclosed in an embodiment of the present invention. Figure 5 As shown, the application's startup control device may include:

[0198] A memory 401 storing executable program codes;

[0199] a processor 402 coupled to the memory 401;

[0200] The processor 402 calls the executable program code stored in the memory 401 to execute the steps in the application startup control method described in the first embodiment of the present invention or the second embodiment of the present invention.

[0201] Embodiment 5

[0202] An embodiment of the present invention discloses a computer storage medium storing computer instructions. When the computer instructions are called, they are used to execute the steps in the application startup control method described in the first embodiment of the present invention or the second embodiment of the present invention.

[0203] Embodiment 6

[0204] An embodiment of the present invention discloses a computer program product, which includes a non-transitory computer-readable storage medium storing a computer program, and the computer program is operable to enable a computer to execute the steps in the startup control method of the application described in Embodiment 1 or Embodiment 2.

[0205] The device embodiments described above are only illustrative, wherein the modules described as separate components may or may not be physically separated, and the components displayed as modules may or may not be physical modules, i.e., they may be located in one place, or they may be distributed on multiple network modules. Some or all of the modules may be selected according to actual needs to achieve the purpose of the scheme of this embodiment. Those of ordinary skill in the art may understand and implement it without creative work.

[0206] Through the specific description of the above embodiments, those skilled in the art can clearly understand that each implementation method can be implemented by means of software plus a necessary general hardware platform, and of course, it can also be implemented by hardware. Based on such an understanding, the above technical solution can be essentially or partly contributed to the prior art in the form of a software product, and the computer software product can be stored in a computer-readable storage medium, and the storage medium includes a read-only memory (ROM), a random access memory (RAM), a programmable read-only memory (PROM), an erasable programmable read-only memory (EPROM), a one-time programmable read-only memory (OTPROM), an electronically erasable rewritable read-only memory (EEPROM), a compact disc (CD-ROM) or other optical disc storage, magnetic disk storage, magnetic tape storage, or any other computer-readable medium that can be used to carry or store data.

[0207] Finally, it should be noted that the method and device for controlling the startup of an application disclosed in the embodiment of the present invention disclose only the preferred embodiments of the present invention, which are only used to illustrate the technical solution of the present invention, rather than to limit it. Although the present invention has been described in detail with reference to the aforementioned embodiments, it should be understood by those skilled in the art that the technical solutions described in the aforementioned embodiments can still be modified, or some of the technical features therein can be replaced by equivalents. However, these modifications or replacements do not deviate the essence of the corresponding technical solutions from the spirit and scope of the technical solutions of the various embodiments of the present invention.

Claims

1. A method for controlling the startup of an application, characterized in that: The method comprises: When receiving a running task analysis instruction of the application, according to the running task analysis instruction, in a first startup process of the application, analyzing at least one running task of the application, and obtaining a task type corresponding to each running task; the task type includes one of a time-consuming running task, a non-time-consuming running task, a privacy running task, a privacy time-consuming running task, a non-privacy non-time-consuming running task, and a privacy non-time-consuming running task; In the second startup process of the application, according to the task type corresponding to each of the running tasks, a matching running operation is performed on each of the running tasks; the matching running operation includes, in the second startup process, based on the version record of the running tasks in the historical storage record, immediately starting the corresponding sub-thread to execute all the time-consuming running tasks, and after obtaining the user's consent instruction, running all the non-time-consuming running tasks in parallel; or, immediately starting the corresponding sub-thread to execute all the time-consuming running tasks and all the privacy-related time-consuming running tasks, and after obtaining the user's consent instruction, running all the privacy-related non-time-consuming running tasks in parallel; It is determined whether all the running tasks are completed, and when it is determined that all the running tasks are completed, a second startup completion instruction of the application is generated.

2. The method for controlling the startup of an application according to claim 1, characterized in that: The analyzing at least one running task of the application to obtain a type corresponding to each running task includes: Calculating the running time of at least one running task of the application; For each of the running tasks, determining whether the running time of the running task is greater than or equal to a preset running time threshold; When it is determined that the running time of the running task is greater than or equal to the preset running time threshold, determining that the running task is a first time-consuming running task; When it is determined that the running time of the running task is less than the preset running time threshold, the running task is determined to be a non-time-consuming running task.

3. The method for controlling the startup of an application according to claim 2, characterized in that: The method further comprises: After all the non-time-consuming running tasks are determined, a first degree of association between each of the non-time-consuming running tasks and the target privacy method set is calculated according to a predetermined target privacy method set; Determine all non-time-consuming running tasks with a first degree of association greater than or equal to a preset first degree of association threshold with the target privacy method set as all privacy running tasks; all the privacy running tasks are running tasks used to collect the privacy data of the target user during the first startup process of the application; The target privacy method set is determined in the following way: Determine a privacy method set according to the determined privacy statement text; the privacy method set is a method set for collecting the private data of the target user; the privacy method set includes at least one privacy method; When the application is not started, obtaining at least one target method of the application, where all the target methods are methods composed of programming files corresponding to the application; According to the privacy method set, calculating a second degree of association between each of the target methods and the privacy method set; All target methods whose second correlation degree with the privacy method set is greater than or equal to a preset second correlation degree threshold are determined as the target privacy method set; the target privacy method set is a method set that can collect the privacy data of the target user in the application.

4. The method for controlling the startup of an application according to claim 3, characterized in that: The method further comprises: After all the privacy running tasks are determined, query the dynamic library corresponding to each of the privacy running tasks, and calculate the loading time of the dynamic library corresponding to each of the privacy running tasks; For each dynamic library corresponding to the privacy running task, determine whether the loading time of the dynamic library is greater than or equal to a preset loading time threshold; When it is determined that the loading time of the dynamic library is greater than or equal to the preset loading time threshold, the privacy running task is determined to be the second time-consuming running task.

5. The method for controlling the startup of an application program according to claim 4, characterized in that: The method further comprises: When it is determined that the loading time of the dynamic library is less than the preset loading time threshold, determining the privacy operation task as the target privacy operation task; The performing of a matching operation on each of the running tasks according to the task type corresponding to each of the running tasks includes: For each of the target privacy operation tasks, generating an operation request instruction matching the target privacy operation task according to the target privacy operation task, and outputting the operation request instruction; the operation request instruction is used to request the target user whether to agree to run the target privacy operation task; Detecting whether a consent execution instruction corresponding to the target privacy execution task has been received; When it is detected that the consent execution instruction has been received, the target privacy execution task is executed.

6. The method for controlling the startup of an application program according to claim 5, characterized in that: The method further comprises: Determine subthreads corresponding to all target time-consuming running tasks; all the target time-consuming running tasks include all the first time-consuming running tasks and all the second time-consuming running tasks; Determine the running priority of each of the target time-consuming running tasks, and start running each of the target time-consuming running tasks according to the running priority of each of the target time-consuming running tasks among all the target time-consuming running tasks and the sub-thread corresponding to the target time-consuming running task; the higher the running priority of each of the target time-consuming running tasks, the earlier the execution order of the target time-consuming running task will be.

7. The method for controlling the startup of an application program according to claim 6, characterized in that: Determining the running priority of each target time-consuming running task includes: For each of the target time-consuming running tasks, determining the running priority of the target time-consuming running task according to the subordinate relationship between the target time-consuming running task and all the target time-consuming running tasks except the target time-consuming running task among all the target time-consuming running tasks; or, Determine the weight corresponding to each of the target time-consuming running tasks according to the business needs of the target user; the weight corresponding to each of the target time-consuming running tasks represents the importance of the target time-consuming running task to the business needs of the target user; The running priority of each target time-consuming running task is determined according to the weight corresponding to each target time-consuming running task; the higher the weight corresponding to each target time-consuming running task, the higher the running priority of the target time-consuming running task.

8. A device for controlling the startup of an application program, characterized in that: The device comprises: an analysis module, configured to, when receiving an operation task analysis instruction of the application, analyze at least one operation task of the application in a first startup process of the application according to the operation task analysis instruction, and obtain a task type corresponding to each operation task; the task type includes one of a time-consuming operation task, a non-time-consuming operation task, a privacy operation task, a privacy time-consuming operation task, a non-privacy non-time-consuming operation task, and a privacy non-time-consuming operation task; A task running module, used for performing a matching running operation on each running task according to the task type corresponding to each running task during the second startup process of the application; the matching running operation includes, during the second startup process, based on the version record of the running task in the historical storage record, immediately starting the corresponding sub-thread to execute all the time-consuming running tasks, and after obtaining the user's consent instruction, running all the non-time-consuming running tasks in parallel; or, immediately starting the corresponding sub-thread to execute all the time-consuming running tasks and all the privacy-related time-consuming running tasks, and after obtaining the user's consent instruction, running all the privacy-related non-time-consuming running tasks in parallel; The judging module is used to judge whether all the running tasks have been completed, and when it is judged that all the running tasks have been completed, generate a second startup completion instruction of the application.

9. A device for controlling the startup of an application, characterized in that: The device comprises: A memory storing executable program code; a processor coupled to the memory; The processor calls the executable program code stored in the memory to execute the startup control method of the application program according to any one of claims 1 to 7.

10. A computer storage medium, characterized in that: The computer storage medium stores computer instructions, and when the computer instructions are called, they are used to execute the startup control method of the application program according to any one of claims 1 to 7.

Images