CN116225357A - A method, system, device, and storage medium for preventing freezing of an application interface - Google Patents

Abstract

The embodiment of the present application discloses a method, system, device and storage medium for preventing freezing of an application interface. In the technical solution provided by the embodiment of the present application, by obtaining the refresh time interval of the screen, when the system time is within the refresh time interval, each specified task is sequentially executed through the main thread; When the set time threshold is reached, the execution of the specified task is stopped, and the application interface drawing process is executed through the main thread at the screen refresh time node, and the time threshold is set according to the refresh time interval. Using the above technical means, by stopping the execution of the specified task when the task time is close to the screen refresh time node, the processing resources of the main thread are used for drawing and refreshing the application interface, so as to ensure that the application interface is refreshed according to the normal frequency. Refresh to avoid screen freeze. Improve the fluency of the application interface display and improve the user experience.

Description

A method, system, device, and storage medium for preventing freezing of an application interface

technical field

The embodiments of the present application relate to the field of computer technology, and in particular, to a method, system, device, and storage medium for preventing freezing of an application interface.

Background technique

At present, with the rapid development of the mobile Internet, the business of application programs is becoming more and more complex. Generally speaking, an application program executes a user interface (UI) drawing process through a main thread, and performs drawing and refreshing of the user interface according to a set screen refresh frequency. In addition, applications often need to initialize many of their own services, business function modules, or third-party libraries when they start. In the initialization task, the main thread of the application needs to perform some related services, such as displaying a picture, performing an animation, and so on.

However, since the main thread of the application program needs to perform interface drawing and other related services, when too much business code in the application program is inserted into the main thread for execution, it will occupy the processing time of the main thread and affect the interface drawing service. At this time, there will be a delay in refreshing the application program interface, resulting in an obvious freeze phenomenon on the screen display, affecting the user experience.

Contents of the invention

Embodiments of the present application provide a method, system, device, and storage medium for preventing application interface freezing, which can predict application interface freezing, improve application interface refreshing fluency, and solve the technical problem of delay in application interface refreshing.

In the first aspect, the embodiment of the present application provides a method for preventing freezing of the application interface, including:

Obtain the refresh interval of the screen, and execute each specified task sequentially through the main thread when the system time is within the refresh interval;

Accumulate the task time consumption of each specified task. When the task time consumption reaches the set time threshold, stop executing the specified task, and execute the application interface drawing process through the main thread at the screen refresh time node. The time threshold is set according to the refresh interval.

In the second aspect, the embodiment of the present application provides an application interface freeze prevention system, including:

The execution module is configured to obtain the refresh time interval of the screen, and when the system time is within the refresh time interval, each specified task is sequentially executed through the main thread;

The prevention module is configured to accumulate the task time consumption of each specified task. When the task time consumption reaches the set time threshold, stop executing the specified task, and execute the application interface drawing process through the main thread at the screen refresh time node. The time threshold is based on Refresh interval settings.

In a third aspect, the embodiment of the present application provides an application interface freeze prevention device, including:

memory and one or more processors;

the memory configured to store one or more programs;

When the one or more programs are executed by the one or more processors, the one or more processors are made to implement the application interface freeze prevention method as described in the first aspect.

In a fourth aspect, an embodiment of the present application provides a computer-readable storage medium, the computer-readable storage medium stores computer-executable instructions, and when executed by a computer processor, the computer-executable instructions are configured to perform the following steps: The method for preventing freezing of the application interface described in the first aspect.

In the fifth aspect, the embodiment of the present application provides a computer program product, the computer program product contains instructions, and when the instructions are run on the computer or the processor, the computer or the processor executes the computer program described in the first aspect. The application interface freeze prevention method.

In the embodiment of the present application, by obtaining the refresh time interval of the screen, when the system time is within the refresh time interval, each specified task is executed sequentially through the main thread; In the case of the threshold, stop executing the specified task, and execute the application interface drawing process through the main thread at the screen refresh time node, and the time threshold is set according to the refresh interval. Using the above technical means, by using the main thread to process related tasks at the refresh time interval of the screen, and accumulating the task time consumption, when the task time consumption reaches the set time threshold and is close to the screen refresh time node, stop executing the specified task, so as to Let the processing resources of the main thread be used for drawing and refreshing the application interface to ensure that the application interface is refreshed according to the normal refresh frequency, thereby avoiding the situation of screen freeze. Improve the fluency of the application interface display and improve the user experience. Moreover, by processing the specified tasks as much as possible at the refresh time interval, the processing resources of the main thread can be fully utilized, and the utilization of technical resources of the main thread can be optimized.

Description of drawings

FIG. 1 is a flow chart of a method for preventing application interface freeze provided by an embodiment of the present application;

Fig. 2 is a schematic diagram of different processing periods of the main thread in the embodiment of the present application;

Fig. 3 is a kind of execution flowchart of the specified task in the embodiment of the present application;

Fig. 4 is another execution flowchart of the specified task in the embodiment of the present application;

Fig. 5 is the business processing flowchart of main thread in the embodiment of the present application;

FIG. 6 is a schematic structural diagram of an application interface freeze prevention system provided by an embodiment of the present application;

Fig. 7 is a schematic structural diagram of an application interface freeze prevention device provided by an embodiment of the present application.

Detailed ways

In order to make the purpose, technical solution and advantages of the present application clearer, specific embodiments of the present application will be further described in detail below in conjunction with the accompanying drawings. It should be understood that the specific embodiments described here are only used to explain the present application, but not to limit the present application. In addition, it should be noted that, for the convenience of description, only parts relevant to the present application are shown in the drawings but not all content. Before discussing the exemplary embodiments in more detail, it should be mentioned that some exemplary embodiments are described as processes or methods depicted as flowcharts. Although the flowcharts describe various operations (or steps) as sequential processing, many of the operations may be performed in parallel, concurrently, or simultaneously. In addition, the order of operations can be rearranged. The process may be terminated when its operations are complete, but may also have additional steps not included in the figure. The processing may correspond to a method, function, procedure, subroutine, subroutine, or the like.

This application provides a method for preventing freezing of the application interface, which aims to use the main thread to process related tasks at the screen refresh time interval, and accumulate task time consumption. When the task time consumption reaches the set time threshold, it is close to the screen refresh time node. In the case of , stop the execution of the specified task, so as to let the processing resources of the main thread be used for drawing and refreshing the application interface, thereby avoiding the situation of screen freezing.

As the application initializes, some tasks inevitably have to be performed in the application's main thread. However, all user interface (UI) drawing processes of the application also need to be performed in the main thread. Therefore, when too much business code in the application program is inserted into the main thread for execution, it will take up the time of the main thread and block the user interface drawing business in the main thread. For the user, the user will feel that there is a delay in refreshing the interface of the application program on the terminal, and there is a relatively obvious picture freeze phenomenon. Based on this, a method for preventing application interface freezing according to an embodiment of the present application is provided to solve the technical problem that there is a delay in refreshing the application interface, which leads to page refreshing freezing.

Example:

Figure 1 shows a flow chart of a method for preventing application interface freezing provided in an embodiment of the present application. The method for preventing application interface freezing provided in this embodiment can be executed by an application interface freezing prevention device. The prevention device may be realized by means of software and/or hardware, and the application interface freeze prevention device may be composed of two or more physical entities, or may be composed of one physical entity. Generally speaking, the application interface freeze prevention device can be a terminal device such as a mobile phone, a computer, a tablet, and a smart watch.

The following description will be made by taking the application interface freeze prevention device as an example for executing the application interface freeze prevention method. Referring to Figure 1, the application interface freeze prevention method specifically includes:

S110. Obtain the refresh time interval of the screen, and execute each specified task sequentially through the main thread when the system time is within the refresh time interval;

S120. Accumulate the task time consumption of each specified task. When the task time consumption reaches the set time threshold, stop executing the specified task, and execute the application interface drawing process through the main thread at the screen refresh time node. The time threshold is based on the refresh time interval set up.

In order to solve the screen freeze problem caused by the application interface refresh delay, the embodiment of the present application provides a preventive solution, using the main thread to process the accumulated time spent on processing related tasks within the screen refresh time interval, and judging that the main thread continues to execute related tasks. Whether the task will affect the processing of the interface drawing task, and then realize the prediction effect of the interface freeze.

When the system draws and refreshes the application interface, it usually draws the application interface according to a fixed refresh rate, that is, the system will execute the interface drawing task at a fixed time interval, and define this time interval as the refresh interval. By determining the refresh time interval of this screen, when the system time enters this time interval, the main thread can be used to perform various related tasks, such as displaying a picture, executing an animation, etc., and defining these related tasks as specified tasks . When the system time is at the screen refresh time node, the application interface drawing task needs to be executed through the main thread. The system only needs to ensure that the main thread can stop executing the specified task at the screen refresh time node, execute the application interface refresh task on time, and ensure that the specified task does not affect the execution of the application interface refresh task, so as to avoid the refresh delay of the application interface and avoid screen freeze Phenomenon, improve application interface refresh fluency.

Different from the existing freeze solution, after discovering the screen freeze problem and finding a reproduction path, use the debugging tool to detect the time-consuming task that caused the freeze and the specific duration of the task, and then remove the time-consuming task and delay execution using This task does not affect the processing method of the current interface drawing and refreshing tasks. In the embodiment of the present application, it is not necessary to clearly know in advance whether there is a freeze, and then to process the freeze task. By no longer executing time-consuming tasks when it is detected that a freeze is about to occur, it prevents time-consuming tasks from blocking the screen refresh, thereby reducing interface freezes, thereby achieving the effect of preventing application interface freezes and responding to screen freezes in a more timely manner problems and improve user experience.

Referring to FIG. 2 , a schematic diagram of different processing periods of the main thread in the implementation of the present application is provided. Among them, T1-T5 represent screen refresh time nodes, and the system will execute application interface drawing and screen refresh services at these time nodes, and display the latest screen status of the current system on the screen, so that users can see the latest screen. t1-t5 represent refresh time intervals. During these periods, the main thread is in an idle state, and there is no need to perform application interface drawing and screen refreshing services. Therefore, this idle refresh time interval can be used to execute specified tasks to ensure full utilization of main thread computing resources.

Based on this, the embodiment of the present application monitors the system time when preventing freezing of the application interface. When the system time is within the refresh time interval, the main thread is invoked to start executing each specified task, that is, related tasks that need to be processed by the main thread. Task. Further, by accumulating the task time consumption of each specified task, the task time consumption is compared with the set time threshold, and when the task time consumption exceeds the set time threshold, the execution of the specified task is stopped, and the main thread's The processing resources are handed over to the application interface drawing and refreshing tasks, and the application interface drawing process is executed through the main thread at the screen refresh time node to avoid delays in interface refresh caused by task conflicts. It should be noted that the time threshold is set according to the above refresh time interval. It can be understood that as long as the accumulated task time does not exceed the refresh time interval, the conflict between the specified task and the application interface drawing and refresh task can be avoided to prevent stuck ton effect. Based on this, by setting the set time threshold corresponding to the refresh time interval, the processing of the specified task can be precisely controlled.

Optionally, the set time threshold is equal to the refresh time interval or less than a set value of the refresh time interval. Generally speaking, if the time threshold is set equal to the refresh interval, the refresh interval can be fully utilized, so that the computing resources of the main thread can process as many specified tasks as possible. However, if the set time threshold is set to be less than the set value of the refresh interval, time at least the set value can be set aside for the main thread to buffer, ensuring that the main thread can switch to the application interface drawing and refreshing tasks on time for processing.

Specifically, referring to FIG. 3, based on the above-mentioned time interval, the specified task processing flow includes:

S1201. After the execution of the current designated task is completed, count the task time consumption of each completed designated task within the refresh time interval;

S1202. Compare the task time consumption with the set time threshold, and stop executing the next specified task when the task time reaches the set time threshold.

Exemplarily, taking the refreshing of the application interface of the mobile phone as an example, the screen refreshing frequency of the current mobile phone system is generally fixed. Taking 60Hz as an example, the screen will be refreshed 60 times per second, which means that the system will execute 60 application interface drawing tasks every second. From this, it can be concluded that the interval between two drawing tasks of the application interface is about 0.0166 seconds (16.6 milliseconds), that is, the refresh time interval. Using the idle interval of 16.6 milliseconds, the main thread of the application program can perform some tasks related to its own business during this idle interval.

If these tasks cannot be completed within this idle interval, it will cause a delay in the next interface refresh, which makes the user feel that the screen is stuck. Based on this, in the embodiment of the present application, after the execution of the specified task is completed within the refresh time interval, the accumulated time spent on the current specified task plus the previously completed specified task is recorded, that is, the time spent on the task. If the time-consuming of this task has reached the set time threshold, it will immediately stop executing the new specified task, free up the resources of the main thread, and transfer the right to use to the system, so that the system can refresh the drawing of the next frame. In order to avoid the occurrence of screen freeze.

It can be understood that, since the application program occupies the main thread usage right during the idle period of the refresh time interval, the application program needs to complete its own designated tasks and transfer the main thread usage right to the system before the refresh time interval ends. However, the business code is often complex and uncontrollable, and it is easy to exceed the refresh interval during the execution of the specified task, so that the system does not obtain the right to use the main thread in time, and cannot draw and refresh the screen at the normal screen refresh time node, resulting in screen The screen is stuck at the previous frame. For users, what they see is that the application freezes and the experience is not good. Therefore, this solution achieves precise control and switching of main thread tasks by accumulating the task time consumption of all completed specified tasks within the time interval after each specified task is completed, and comparing the task time consumption with the set time threshold. Avoid screen refresh delays.

It should be noted that the time consumption of the task is accumulated after the execution of the specified task is completed. If the set time threshold is set equal to the refresh interval, it may happen that when the previous specified task is completed, the accumulated time consumption of the task does not When the set time threshold is reached, continue to execute the next specified task at this time, the accumulated task time exceeds the refresh interval and the specified task is still not completed. Based on this, the embodiment of the present application sets the set time threshold to be less than the set value of the refresh time interval, so that the execution of the specified task can be stopped in time when the task time is close to the refresh time interval, and the above-mentioned accumulated tasks can be avoided. The situation where the specified task is still not completed when the time-consuming exceeds the refresh interval.

In one embodiment, referring to FIG. 4 , the task time consumption of each specified task is accumulated above, and when the task time consumption reaches the set time threshold, the execution of the specified task is stopped, and further includes:

S1203. Before executing the current designated task, determine the predicted time consumption of the current designated task, and determine the task time consumption according to the cumulative time consumption and the predicted time consumption of each completed designated task within the refresh time interval;

S1204. Compare the task time consumption with the set time threshold, and stop executing the currently specified task when the task time reaches the set time threshold.

Different from the above scheme of accumulating the time consumption of tasks after the specified tasks are completed, this embodiment of the present application can also predict the time consumption of a single task for the specified tasks to be processed, and determine After the specified task that is currently ready to be executed is completed, the task time of each specified task that has been executed within this refresh interval. By means of the specified task time-consuming prediction method, the approximate prediction result of the total task time consumption after the current specified task is executed is obtained. It is understandable that if the task takes longer than the set time threshold at this time, if it points to the currently specified task, the main thread will not be able to process the application interface drawing and refreshing tasks in time, resulting in a delay in interface refreshing. Therefore, it is necessary to stop the execution of the currently specified task. Conversely, if the task time consumption does not exceed the set time threshold at this time, the currently specified task can be executed to make full use of the main thread computing resources.

Optionally, the embodiment of the present application determines the predicted time consumption of the currently specified task, including:

Obtain the task type of the currently specified task, query the pre-built mapping relationship based on the task type of the currently specified task, and obtain the predicted time consumption of the currently specified task, and set the corresponding predicted time consumption for the mapping relationship in advance corresponding to different task types.

It can be understood that, for the specified tasks of different task types, the processing time will be in a general range. According to different task types, by manually setting the reasonable processing time in advance, the processing time is The predicted time consumption of the specified task of the corresponding type. Furthermore, different types of specified tasks are bound to their predicted time-consuming to build a mapping relationship. Then, according to the determined task type, the corresponding predicted time-consuming can be determined by querying the mapping relationship, and then it is judged whether to execute the current specified task according to the predicted time-consuming.

In one embodiment, according to the predicted time consumption of the main thread processing different types of specified tasks, the system can also pre-layout tasks to be processed in the current refresh interval according to the total duration of the refresh interval when the system time enters the refresh interval. each assigned task. The sum of the predicted time consumption of these specified tasks must be less than or equal to the refresh interval. By pre-determining all specified tasks to be processed within the refresh interval and providing an accurate task processing expectation, the task scheduling effect of the system can be optimized, and the stability and reliability of each specified task processing can be improved.

In one embodiment, the time-consuming prediction of the currently designated task can also be performed according to attribute information such as the specific task content of the currently designated task. The embodiment of the present application does not impose fixed restrictions on specific time-consuming prediction schemes, and details are not repeated here.

In addition, before executing the current specified task, the embodiment of the present application also includes: obtaining the cumulative time consumption of each specified task that has been executed within the refresh interval, and when the time difference between the cumulative time consumption and the set time threshold is less than the set duration Next, stop executing the specified task. It can be understood that if the set time threshold is set equal to the refresh interval, it may happen that when the previous specified task is completed, the accumulated task time consumption does not reach the set time threshold, and the next specified task will continue to be executed at this time. The accumulated task time exceeds the refresh interval and the specified task is still not completed. Based on this, the application terminates the execution of the specified task in advance when the time difference between the cumulative time-consuming of each completed specified task and the set time threshold is less than the set time, so as to reserve an appropriate buffer time for the main thread Switch tasks, prepare for the screen drawing and refreshing process, and ensure the smoothness of screen drawing and refreshing.

Exemplarily, referring to steps a1 to a7 in FIG. 5 , after the system is started, the screen refresh frequency of the current system is first obtained through the above-mentioned application interface freeze prevention method, and the refresh time interval is determined based on the refresh frequency. Then, after it is determined that the system enters the screen refresh time interval, the system enters a loop. Referring to FIG. 5 , after the system finishes drawing and refreshing the screen picture each time, it will notify the application program to enter the idle state, that is, the refresh time interval. After entering the refresh interval, the system will hand over the main thread resources to the application program, and start to use the main thread to execute the specified tasks. After each specified task is completed, check whether the accumulated task time has reached the set time threshold. If the task time is less than the set time threshold, it means that the system time has not reached the next screen drawing time node, and the system is still in the idle interval. You can proceed to the next specified task. At this time, the flow comes to a7, and the next specified task is started. After the execution of the next specified task is completed, record the time consumed by this task, and update the cumulative time spent on the completed specified task. Go to step a4 again, and re-judge whether the accumulated task time has reached the set time threshold.

By analogy, if it is detected in step a4 that the accumulated task time consumption has reached the set time threshold, it means that the current refresh time interval has been exhausted, and the system needs to immediately refresh the screen image. At this time, the process enters a5, and the affected program stops executing new specified tasks, and transfers the right to use the main thread to the system. When the process reaches a6, the system will refresh the screen at the expected screen refresh time node, and the screen image will be refreshed as scheduled, and the image seen by the user will not appear stuck. Similarly, after the system finishes drawing and refreshing the screen, it enters the idle state of the refresh time interval again, and the right to use the main thread is handed over to the application program again. Based on the above-mentioned application interface freeze prevention method, the application interface freeze prevention operation is cyclically performed.

During the whole cycle, by continuously checking whether the specified task of each refresh time interval takes too much time, timely discovering the hidden danger of jamming may occur, so as to actively release the right to use the main thread, so that the system can normally obtain the refresh time node of the screen The right to use the main thread to perform screen drawing and refreshing tasks. In this way, during the running process of the application, it is continuously detected whether the predicted freeze is about to occur, and the resources of the main thread are released in time, so as to avoid the freeze and solve the freeze problem once and for all.

As mentioned above, by obtaining the refresh time interval of the screen, when the system time is within the refresh time interval, each specified task is executed sequentially through the main thread; then the task time consumption of each specified task is accumulated, and when the task time consumption reaches the set time threshold In this case, stop executing the specified task, and execute the application interface drawing process through the main thread at the screen refresh time node, and the time threshold is set according to the refresh interval. Using the above technical means, by using the main thread to process related tasks at the refresh time interval of the screen, and accumulating the task time consumption, when the task time consumption reaches the set time threshold and is close to the screen refresh time node, stop executing the specified task, so as to Let the processing resources of the main thread be used for drawing and refreshing the application interface to ensure that the application interface is refreshed according to the normal refresh frequency, thereby avoiding the situation of screen freeze. Improve the fluency of the application interface display and improve the user experience. Moreover, by processing the specified tasks as much as possible at the refresh time interval, the processing resources of the main thread can be fully utilized, and the utilization of technical resources of the main thread can be optimized.

On the basis of the above-mentioned embodiments, FIG. 6 is a schematic structural diagram of an application interface freeze prevention system provided by the present application. Referring to FIG. 6 , the application interface freeze prevention system provided by this embodiment specifically includes: an execution module 21 and a prevention module 22 .

Wherein, the execution module 21 is configured to obtain the refresh time interval of the screen, and when the system time is within the refresh time interval, each specified task is sequentially executed through the main thread;

The prevention module 22 is configured to accumulate the task time consumption of each specified task. When the task time consumption reaches the set time threshold, stop executing the specified task, and execute the application interface drawing process through the main thread at the screen refresh time node. The time threshold is based on Refresh interval settings.

Specifically, the task time consumption of each specified task is accumulated, and when the task time consumption reaches the set time threshold, the execution of the specified task is stopped, including:

After the execution of the current specified task is completed, the task time consumption of each specified task that has been executed within the statistical refresh interval;

Compare the task time consumption with the set time threshold, and stop executing the next specified task when the task time reaches the set time threshold. Wherein, the set time threshold is equal to the refresh time interval or less than a set value of the refresh time interval.

Specifically, accumulating the task time consumption of each specified task, and stopping the execution of the specified task when the task time consumption reaches the set time threshold, also includes:

Before executing the currently specified task, determine the predicted time consumption of the current specified task, and determine the task time consumption according to the cumulative time consumption and predicted time consumption of each completed specified task within the refresh interval;

Compare the task time consumption with the set time threshold, and stop executing the currently specified task when the task time reaches the set time threshold.

Specifically, determine the predicted time consumption of the currently specified task, including:

Obtain the task type of the currently specified task, query the pre-built mapping relationship based on the task type of the currently specified task, and obtain the predicted time consumption of the currently specified task, and set the corresponding predicted time consumption for the mapping relationship in advance corresponding to different task types.

Specifically, before executing the currently specified task, it also includes:

Acquire the cumulative time consumption of each specified task that has been executed within the refresh interval, and stop executing the specified task if the time difference between the cumulative time consumption and the set time threshold is less than the set duration.

As mentioned above, by obtaining the refresh time interval of the screen, when the system time is within the refresh time interval, each specified task is executed sequentially through the main thread; then the task time consumption of each specified task is accumulated, and when the task time consumption reaches the set time threshold In this case, stop executing the specified task, and execute the application interface drawing process through the main thread at the screen refresh time node, and the time threshold is set according to the refresh interval. Using the above technical means, by using the main thread to process related tasks at the refresh time interval of the screen, and accumulating the task time consumption, when the task time consumption reaches the set time threshold and is close to the screen refresh time node, stop executing the specified task, so as to Let the processing resources of the main thread be used for drawing and refreshing the application interface to ensure that the application interface is refreshed according to the normal refresh frequency, thereby avoiding the situation of screen freeze. Improve the fluency of the application interface display and improve the user experience. Moreover, by processing the specified tasks as much as possible at the refresh time interval, the processing resources of the main thread can be fully utilized, and the utilization of technical resources of the main thread can be optimized.

The application interface freeze prevention system provided in the embodiments of the present application can be configured to execute the application interface freeze prevention method provided in the above embodiments, and has corresponding functions and beneficial effects.

On the basis of the above practical examples, the embodiment of the present application also provides an application interface freeze prevention device. Referring to FIG. 7, the application interface freeze prevention device includes: a processor 31, a memory 32, a communication module 33, an input device 34 and output device 35 . The memory 32, as a computer-readable storage medium, can be configured to store software programs, computer-executable programs and modules, such as program instructions/modules corresponding to the application interface freeze prevention method described in any embodiment of the present application (for example, application Execution module and prevention module in the interface freeze prevention system). The communication module 33 is configured to perform data transmission. The processor executes various functional applications and data processing of the device by running the software programs, instructions and modules stored in the memory, that is, realizes the above-mentioned method for preventing freezing of the application interface. The input device 34 may be configured to receive input of numeric or character information, and to generate key signal input related to user settings and function control of the device. The output device 35 may include a display device such as a display screen. The application interface freeze prevention device provided above can be configured to execute the application interface freeze prevention method provided in the above embodiment, and has corresponding functions and beneficial effects.

On the basis of the above-mentioned embodiments, the embodiments of the present application also provide a computer-readable storage medium, the computer-readable storage medium stores computer-executable instructions, and when the computer-executable instructions are executed by a computer processor It is configured to implement a method for preventing application interface freeze, and the storage medium may be any storage device or storage device of various types. Of course, the computer-readable storage medium provided in the embodiments of the present application, its computer-executable instructions are not limited to the method for preventing application interface freezing as described above, and can also execute the application interface freezing provided in any embodiment of the application Related actions in the prevention method.

On the basis of the above-mentioned embodiments, the embodiments of the present application also provide a computer program product. The technical solution of the present application is essentially or the part that contributes to the prior art or all or part of the technical solution can be implemented as a software product It is embodied in the form that the computer program product is stored in a storage medium, and includes several instructions to enable a computer device, a mobile terminal, or a processor therein to execute all of the methods for preventing application interface freezing in various embodiments of the present application. or partial steps.

Claims (10)

1. An application interface jamming prevention method, comprising:

acquiring a refreshing time interval of a screen, and sequentially executing each appointed task through a main thread under the condition that the system time is in the refreshing time interval;

and accumulating the task time consumption of each appointed task, stopping executing the appointed task under the condition that the task time consumption reaches a set time threshold, and executing an application interface drawing process through the main thread at a screen refreshing time node, wherein the time threshold is set according to the refreshing time interval.

2. The method for preventing application interface jamming according to claim 1, wherein accumulating task time consumption of each of the specified tasks, and stopping execution of the specified tasks if the task time consumption reaches a set time threshold, comprises:

after the execution of the current appointed task is completed, counting the time consumption of each executed appointed task in the refreshing time interval;

comparing the task time consumption with the set time threshold, and stopping executing the next designated task when the task time consumption reaches the set time threshold.

3. The application interface jamming prevention method according to any one of claims 1-2, wherein the set time threshold is equal to the refresh time interval or less than the refresh time interval set point.

4. The application interface jamming prevention method according to claim 1, wherein the accumulating task time consumption of each of the specified tasks stops executing the specified tasks if the task time consumption reaches a set time threshold, further comprising:

before executing the current specified task, determining the predicted time consumption of the current specified task, and determining the task time consumption according to the accumulated time consumption of each executed specified task and the predicted time consumption in the refresh time interval;

comparing the task time consumption with the set time threshold, and stopping executing the current designated task when the task time consumption reaches the set time threshold.

5. The application interface jam prevention method of claim 4, wherein said determining the predicted time consumption of the current specified task includes:

acquiring the task type of the current appointed task, inquiring a pre-constructed mapping relation based on the task type of the current appointed task, and acquiring the predicted time consumption of the current appointed task, wherein the mapping relation is used for setting corresponding predicted time consumption in advance corresponding to different task types.

6. The application interface jam prevention method of claim 4, further comprising, prior to executing the current specified task:

and acquiring the accumulated time consumption of each executed appointed task in the refreshing time interval, and stopping executing the appointed task when the time difference between the accumulated time consumption and the set time threshold is smaller than the set time length.

7. An application interface jamming prevention system, comprising:

the execution module is configured to acquire a refreshing time interval of the screen, and sequentially execute each appointed task through the main thread under the condition that the system time is in the refreshing time interval;

and the prevention module is configured to accumulate the task time consumption of each designated task, stop executing the designated task when the task time consumption reaches a set time threshold, and execute an application interface drawing process through the main thread at a screen refreshing time node, wherein the time threshold is set according to the refreshing time interval.

8. An application interface jamming prevention device, comprising:

a memory and one or more processors;

the memory is configured to store one or more programs;

when executed by the one or more processors, causes the one or more processors to implement the application interface jam-prevention method of any of claims 1-6.

9. A computer readable storage medium storing computer executable instructions which, when executed by a computer processor, are configured to perform the application interface jam prevention method of any of claims 1-6.

10. A computer program product comprising instructions which, when executed on a computer or processor, cause the computer or processor to perform the application interface jam prevention method of any of claims 1-6.

Images