Time slice-based loading method and system, storage medium and computer device thereof

Abstract

This invention relates to the field of Android system screen refresh technology, and provides a loading method based on time-slice partitioning, comprising: dividing at least two controls within the same frame into at least two control groups according to the system's refresh frame rate; storing the control groups in a message queue with a preset priority; when the system screen refreshes, retrieving the control groups from the message queue according to the priority, and drawing the control groups one by one on consecutive frames. It also provides a loading system based on time-slice partitioning, a storage medium for storing a computer program executing the method, and a computer device for implementing the method. Therefore, this invention can solve the lag problem of Android system interface refresh.

Description

Technical Field

[0001] This invention relates to the field of Android system screen refresh technology, and in particular to a loading method, system, storage medium and computer device based on time slices. Background Technology

[0002] When loading or refreshing a large number of controls, the UI refresh rate decreases, and the single-frame rendering time is delayed, resulting in noticeable stuttering. When loading or refreshing a large number of controls, the Android system loads and renders them all on the screen at once. If the time it takes to render these controls exceeds the phone's refresh rate, frames are dropped, creating a stuttering visual feedback for the user. Even asynchronous loading only solves the one-time loading problem and cannot address the issue of complex screen refresh efficiency.

[0003] In summary, the existing methods have many problems in practical use, so it is necessary to improve them. Summary of the Invention

[0004] To address the aforementioned shortcomings, the present invention aims to provide a loading method, system, storage medium, and computer device based on time-slice partitioning to solve the lag problem of Android system interface refresh.

[0005] To achieve the above objectives, the present invention provides a loading method based on time slices, characterized in that it includes:

[0006] Based on the system's refresh frame rate, at least two controls within the same frame are divided into at least two groups of controls.

[0007] The control group is stored in the message queue with a preset priority;

[0008] When the system screen refreshes, the control group is retrieved from the message queue according to the priority, and the control group is drawn one by one on multiple consecutive frames.

[0009] According to the loading method based on time slices, the step of storing the control group in the message queue with a preset priority includes:

[0010] Each of the control groups is assembled into a message, and the message is stored in the message queue.

[0011] Preferably, the step of retrieving the control group from the message queue according to the priority when the system screen refreshes, and drawing the control group one by one on multiple consecutive frames, further includes:

[0012] Register a system refresh mechanism to monitor system screen refreshes;

[0013] When the system screen refreshes, the system refresh mechanism is called back to retrieve one of the messages from the message queue;

[0014] Perform the function according to the content of the message to draw the control group one by one on multiple consecutive frames.

[0015] More preferably, the step of retrieving the control group from the message queue according to the priority when the system screen refreshes, and drawing the control group one by one on multiple consecutive frames, includes:

[0016] The extracted message is sent to the system's main thread message processing.

[0017] A loading system based on time-slicing is also provided, including:

[0018] The partitioning unit is used to divide at least two controls within the same frame into at least two groups of controls based on the system's refresh frame rate.

[0019] A storage unit is used to store the control group into a message queue with a preset priority;

[0020] An extraction drawing unit is used to extract the control group from the message queue according to the priority when the system screen refreshes, and draw the control group one by one on multiple consecutive frames.

[0021] The storage unit is specifically used for:

[0022] Each of the control groups is assembled into a message, and the message is stored in the message queue.

[0023] Preferably, the extraction and drawing unit includes:

[0024] The registration subunit is used to register a system refresh mechanism to listen for system screen refreshes;

[0025] An extraction subunit is used to extract a message from the message queue when the system screen refreshes;

[0026] A drawing subunit is used to perform function execution according to the content of the message to draw the control group one by one on multiple consecutive frames.

[0027] Even better, the extraction and drawing unit is also used to send the extracted message to the system's main thread message processing.

[0028] Additionally, a storage medium and a computer device are provided, the storage medium being used to store a computer program for executing the above-described loading method based on time slices.

[0029] The computer device includes a storage medium, a processor, and a computer program stored on the storage medium and executable on the processor. When the processor executes the computer program, it implements the above-described loading method based on time slices.

[0030] The loading method based on time-slice division described in this invention uses time-slice loading technology to distribute the drawing of controls that would normally require one frame across multiple consecutive frames, thus solving the stuttering problem. It also provides a loading system based on time-slice division, a storage medium for storing a computer program executing the method, and a computer device for implementing the method. Attached Figure Description

[0031] Figure 1 The flowchart illustrates the steps of the loading method based on time slices used in a preferred embodiment of the present invention.

[0032] Figure 2 This is a structural block diagram of the loading system based on time slices according to a preferred embodiment of the present invention;

[0033] Figure 3 This is a schematic block diagram illustrating the specific structure of the loading system based on time slices according to a preferred embodiment of the present invention. Detailed Implementation

[0034] To make the objectives, technical solutions, and advantages of this invention clearer, the invention will be further described in detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the invention.

[0035] It should be noted that references to "an embodiment," "embodiment," "example embodiment," etc., in this specification refer to the described embodiment including specific features, structures, or characteristics, but not every embodiment must include these specific features, structures, or characteristics. Furthermore, such expressions do not refer to the same embodiment. Moreover, when describing specific features, structures, or characteristics in conjunction with embodiments, whether or not explicitly described, it is indicated that incorporating such features, structures, or characteristics into other embodiments is within the knowledge of those skilled in the art.

[0036] Furthermore, certain terms are used in the specification and subsequent claims to refer to specific components or parts. Those skilled in the art will understand that manufacturers may use different names or terms to refer to the same component or part. This specification and subsequent claims do not distinguish components or parts by differences in name, but rather by differences in function. The terms "comprising" and "including" used throughout the specification and subsequent claims are open-ended and should be interpreted as "including but not limited to." Additionally, the term "connection" here includes any direct and indirect electrical connection means. Indirect electrical connection means include connections made through other means.

[0037] Figure 2 This invention illustrates a preferred embodiment of a loading system 100 based on time-slice partitioning, specifically applied to an Android mobile terminal; it includes a partitioning unit 10, a storage unit 20, and an extraction and rendering unit 30; wherein:

[0038] The partitioning unit 10 is used to divide at least two controls within the same frame into at least two control groups according to the system's refresh frame rate; that is, multiple or excessive controls within the same frame are divided into multiple control groups, each control group containing at least one control, i.e., multiple controls within the same frame are divided into multiple parts, which can be evenly or unevenly divided; the storage unit 20 is used to store the control groups into a message queue with a preset priority; multiple control groups are stored into the message queue according to a preset priority, i.e., different control groups have different priorities, so as to facilitate subsequent retrieval and retrieval; the extraction and drawing unit 30 is used to extract the control groups from the message queue according to the priority when the system screen refreshes, and draw the control groups one by one on multiple consecutive frames. That is, after multiple or excessive controls within the same frame are divided, they are drawn onto multiple consecutive frames, thereby solving the stuttering problem of Android system interface refresh.

[0039] The storage unit 20 in this embodiment is specifically used to: assemble each control group into a message, and store the message in the message queue. One message corresponds to one control group, the message is stored in the message queue in a specific format, and the content of the message includes multiple controls in the corresponding control group and their priorities, etc.

[0040] See Figure 3 The extraction and drawing unit 30 includes a registration subunit 301, an extraction subunit 302, and a drawing subunit 303, wherein:

[0041] The registration subunit 301 is used to register a system refresh mechanism to listen for system screen refresh; the extraction subunit 302 is used to have the system refresh mechanism call back when the system screen refreshes to extract a message from the message queue; the drawing subunit 303 is used to perform function execution according to the content of the message to draw the control group one by one on multiple consecutive frames.

[0042] The preferred system refresh mechanism is the Android system's Choreographer mechanism (a message handler that calculates the frame (control) based on the field synchronization signal; the frame calculation involves handling three types of callbacks: event callbacks, animation callbacks, and drawing callbacks). Choreographer is the system refresh mechanism, refreshing 60 times per minute, or once every 16.7ms. After loading controls into N groups, each group is assembled into a message and placed in a queue. Then, a Choreographer listener is registered. Choreographer will call back when the screen refreshes. Each callback first retrieves a message from the queue and then executes it according to the message's content.

[0043] Specifically, the extraction and rendering unit 30 is also used to send the extracted message to the system's main thread message processing. Each time the screen loads or refreshes, a signal is registered with the system Choreographer. When the screen refreshes, the data in the queue is retrieved and posted to the system Handler, which then refreshes the screen. Here, the system Handler is the Android main thread message processing.

[0044] In other embodiments, a first detection unit is further included, which is used to detect whether the message exists in the message queue; the registration subunit is used to register the system refresh mechanism if the message exists. Whenever a system refresh signal arrives, it is necessary to determine whether there is still data in the message queue. If there is data, registration continues, and the data is retrieved and sent to the Handler.

[0045] Even better, the storage unit 20 further includes an identification subunit and a second detection unit; wherein: the identification subunit is used to identify the assembled message with a message ID (Identity Document ID); the second detection unit is used to detect whether there is a message with the same ID in the message queue, and if so, to replace the message with the same message ID. Each message stored in the queue has a corresponding message ID. Storing a message triggers processing for each message, and processing proceeds sequentially from one message to the next. When a message is added to the queue, it is checked whether the message already exists. If the same message exists, the message to be stored replaces the existing message, and then the message processing logic continues. If the new refresh message and the unexecuted refresh message are of the same type, they are replaced, thereby reducing the number of invalid refreshes. Furthermore, this technology can also address the time-consuming problem caused by the accumulation of business processes in the Android main thread; this technology is a synchronous operation and will not cause data corruption.

[0046] In other embodiments, it further includes a flag setting unit and a flag removal unit; wherein:

[0047] The flag setting unit is used to set a flag on the system refresh link and determine whether a refresh is needed based on the flag; the removal unit is used to remove the message from the message queue if a refresh is not needed. This technology uses system screen signals for triggering operations, can be synchronized with UI refresh, and will not cause refresh asynchrony problems.

[0048] Since Android's refresh mechanism is controlled by the system itself, our handling of specific refreshes involves intercepting the system refresh process and setting flags to determine whether a refresh is needed. For example, a custom ViewGroup (Android's UI is composed of Views, ViewGroups, and their derived classes. View is the base class for all UI components, while ViewGroup is the container for these components and is itself derived from View) can have flags added to the ViewGroup's onMeasure, onLayout, and onDraw methods (the corresponding steps). If the current message being processed is a UI refresh for that ViewGroup, the flag is set to true before processing the message, indicating that a refresh is required. This achieves partial refresh; the remaining ViewGroups do not need to be refreshed. Different ViewGroups have their own flags.

[0049] Preferably, the partitioning unit 10 is specifically used to: divide at least two controls within the same frame into control groups with a number of groups less than or equal to the number of frames, based on the number of frames refreshed per second by the system. The Choreographer mentioned above is the system refresh mechanism, refreshing 60 times per minute, or once every 16.7ms. Each 16.7ms period constitutes a frame, divided into N groups, with each group processed within a consecutive 16.7ms interval; this distributes the control drawn in one frame across multiple consecutive frames, solving the stuttering problem.

[0050] It also includes a configuration unit, which is used to configure the priority according to the type and / or date of the control; or it can be manually arranged according to the actual scenario.

[0051] Figure 1 The preferred embodiment of the loading method based on time slices of the present invention is shown, including the following steps:

[0052] S101: Based on the system's refresh rate, divide at least two controls within the same frame into at least two control groups. That is, multiple or excessive controls within the same frame are divided into multiple control groups, and each control group contains at least one control. In other words, multiple controls within the same frame are divided into multiple parts, which can be evenly or unevenly divided.

[0053] S102: Store the control groups in a message queue with a preset priority. Multiple control groups are stored in the message queue with a preset priority, meaning different control groups have different priorities to facilitate subsequent retrieval and retrieval.

[0054] S103: When the system screen refreshes, the control group is retrieved from the message queue according to the priority, and the control group is drawn one by one on multiple consecutive frames. That is, multiple or excessive controls within the same frame are divided and drawn on multiple consecutive frames, thereby solving the stuttering problem of Android system interface refresh.

[0055] Step S102 includes:

[0056] Each of the aforementioned control groups is assembled into a message, and the message is stored in the message queue. One message corresponds to one control group, and the message is stored in the message queue in a specific format. The content of the message includes multiple controls in the corresponding control group and their priorities, etc.

[0057] Preferably, step S103 further includes:

[0058] Register a system refresh mechanism to monitor system screen refreshes;

[0059] When the system screen refreshes, the system refresh mechanism is called back to retrieve one of the messages from the message queue;

[0060] Perform the function according to the content of the message to draw the control group one by one on multiple consecutive frames.

[0061] The preferred system refresh mechanism is the Android system's Choreographer mechanism (a message handler that calculates the frame (control) based on the field synchronization signal; the frame calculation involves handling three types of callbacks: event callbacks, animation callbacks, and drawing callbacks). Choreographer is the system refresh mechanism, refreshing 60 times per minute, or once every 16.7ms. After loading controls into N groups, each group is assembled into a message and placed in a queue. Then, a Choreographer listener is registered. Choreographer will call back when the screen refreshes. Each callback first retrieves a message from the queue and then executes it according to the message's content.

[0062] More preferably, step S103 includes: sending the extracted message to the system's main thread message processing. Each time the screen loads or refreshes, a signal is registered with the system Choreographer. When the screen refreshes, the data in the queue is retrieved and posted to the system Handler, which then refreshes the screen. Here, the system Handler is the Android main thread message processing.

[0063] Furthermore, prior to step S103, the following is included:

[0064] Detect whether the message exists in the message queue;

[0065] If the message exists, then register the system refresh mechanism.

[0066] Whenever a system refresh signal arrives, it is necessary to check whether there is still data in the message queue. If there is data, the registration process continues, and the data is retrieved and sent to the Handler.

[0067] Step S102 further includes:

[0068] The assembled message is identified by a message ID;

[0069] Check if there is a message with the same ID in the message queue. If so, replace the message with the same ID.

[0070] Each message stored in the queue has a corresponding message ID. Storing a message triggers its processing; multiple messages are processed sequentially, one at a time. When a message is added to the queue, it's checked if the same message already exists. If it does, the message to be stored replaces the existing one, and the message processing logic continues. If the new refresh message and an unexecuted refresh message are of the same type, the message is replaced, thus reducing the number of invalid refreshes. This technology can also address time-consuming issues caused by the accumulation of business processes on the Android main thread; as it's a synchronous operation, it won't cause data corruption.

[0071] In other embodiments, step S102 is further followed by:

[0072] Set a flag on the system refresh link, and determine whether a refresh is needed based on the flag;

[0073] If a refresh is not required, the message is removed from the message queue. This technology uses system screen signals for triggering operations, ensuring synchronization with UI refresh and preventing refresh asynchrony issues.

[0074] Since Android's refresh mechanism is controlled by the system itself, our handling of specific refreshes involves intercepting the system refresh process and setting flags to determine whether a refresh is needed. For example, a custom ViewGroup (Android's UI is composed of Views, ViewGroups, and their derived classes. View is the base class for all UI components, while ViewGroup is the container for these components and is itself derived from View) can have flags added to the ViewGroup's onMeasure, onLayout, and onDraw methods (the corresponding steps). If the current message being processed is a UI refresh for that ViewGroup, the flag is set to true before processing the message, indicating that a refresh is required. This achieves partial refresh; the remaining ViewGroups do not need to be refreshed. Different ViewGroups have their own flags.

[0075] Step S101 further includes:

[0076] Based on the system's frame rate per second, at least two controls within the same frame are divided into control groups with a number less than or equal to the number of frames. The Choreographer mentioned above is the system refresh mechanism, refreshing 60 times per minute, or once every 16.7ms. Each 16.7ms period constitutes a frame, divided into N groups, with each group processed within a consecutive 16.7ms interval. This distributes the control rendering in one frame across multiple consecutive frames, resolving the stuttering issue.

[0077] Before step S102, the following are included:

[0078] Configure the priority based on the type and / or date of the control.

[0079] The present invention also provides a storage medium for storing, for example, Figures 1-2 The computer program based on the time-slicing loading method is described. For example, computer program instructions, when executed by a computer, can invoke or provide the methods and / or technical solutions according to this application through the operation of the computer. The program instructions invoking the methods of this application may be stored in a fixed or removable storage medium, and / or transmitted via data streams in broadcast or other signal carrying media, and / or stored in the storage medium of a computer device operating according to the program instructions. Here, one embodiment according to this application includes, as... Figure 3 The computer device shown is based on a time-slice loading system. The computer device preferably includes a storage medium for storing a computer program and a processor for executing the computer program. When the computer program is executed by the processor, the computer device is triggered to execute the methods and / or technical solutions based on the foregoing embodiments.

[0080] It should be noted that this application can be implemented in software and / or a combination of software and hardware, for example, using an application-specific integrated circuit (ASIC), a general-purpose computer, or any other similar hardware device. In one embodiment, the software program of this application can be executed by a processor to implement the steps or functions described above. Similarly, the software program of this application (including related data structures) can be stored in a computer-readable recording medium, such as RAM memory, magnetic or optical drives, floppy disks, and similar devices. Furthermore, some steps or functions of this application can be implemented in hardware, for example, as circuitry that works with a processor to perform the various steps or functions.

[0081] The method according to the invention can be implemented on a computer as a computer-implemented method, or in dedicated hardware, or a combination of both. Executable code or portions thereof for the method according to the invention can be stored on a computer program product. Examples of computer program products include memory devices, optical storage devices, integrated circuits, servers, online software, etc. Preferably, the computer program product includes non-transitory program code components stored on a computer-readable medium so as to execute the method according to the invention when the program product is executed on a computer.

[0082] In a preferred embodiment, the computer program includes computer program code components adapted to perform all the steps of the method according to the invention when the computer program is run on a computer. Preferably, the computer program is embodied on a computer-readable medium.

[0083] In summary, the loading method based on time-slice division described in this invention uses time-slice loading technology to distribute the drawing of controls that would normally require one frame across multiple consecutive frames, thus solving the stuttering problem. It also provides a loading system based on time-slice division, a storage medium for storing a computer program executing the method, and a computer device for implementing the method.

[0084] Of course, the present invention may have other various embodiments. Without departing from the spirit and essence of the present invention, those skilled in the art can make various corresponding changes and modifications according to the present invention, but these corresponding changes and modifications should all fall within the protection scope of the appended claims.

[0085] This invention also discloses A1, a loading method based on time slices, comprising:

[0086] Based on the system's refresh frame rate, at least two controls within the same frame are divided into at least two groups of controls.

[0087] The control group is stored in the message queue with a preset priority;

[0088] When the system screen refreshes, the control group is retrieved from the message queue according to the priority, and the control group is drawn one by one on multiple consecutive frames.

[0089] A2. According to the loading method based on time slices described in A1, the step of storing the control group in the message queue with a preset priority includes:

[0090] Each of the control groups is assembled into a message, and the message is stored in the message queue.

[0091] A3. According to the loading method based on time slices described in A2, the step of retrieving the control group from the message queue according to the priority when the system screen refreshes, and drawing the control group one by one on multiple consecutive frames, further includes:

[0092] Register a system refresh mechanism to monitor system screen refreshes;

[0093] When the system screen refreshes, the system refresh mechanism is called back to retrieve one of the messages from the message queue;

[0094] Perform the function according to the content of the message to draw the control group one by one on multiple consecutive frames.

[0095] A4. According to the loading method based on time slices described in A3, the step of retrieving the control group from the message queue according to the priority when the system screen refreshes, and drawing the control group one by one on multiple consecutive frames, includes:

[0096] The extracted message is sent to the system's main thread message processing.

[0097] A5. According to the loading method based on time slices described in A3, the step of retrieving the control group from the message queue according to the priority when the system screen refreshes, and drawing the control group one by one on multiple consecutive frames, includes the following:

[0098] Detect whether the message exists in the message queue;

[0099] If the message exists, then register the system refresh mechanism.

[0100] A6. According to the loading method based on time slices described in A2, the step of storing the control group in the message queue with a preset priority further includes:

[0101] The assembled message is identified by a message ID;

[0102] Check if there is a message with the same ID in the message queue. If so, replace the message with the same ID.

[0103] A7. According to the loading method based on time slices described in A2, the step of storing the control group in the message queue with a preset priority includes:

[0104] Set a flag on the system refresh link, and determine whether a refresh is needed based on the flag;

[0105] If a refresh is not required, the message is removed from the message queue.

[0106] A8. According to the loading method based on time slices described in A1, the step of cutting at least two controls within the same frame into at least two groups of controls according to the system's refresh frame rate further includes:

[0107] Based on the number of frames refreshed per second by the system, at least two controls within the same frame are divided into control groups with a number of groups less than or equal to the number of frames.

[0108] A9. According to the loading method based on time slices described in A1, the step of storing the control group in the message queue with a preset priority includes:

[0109] Configure the priority based on the type and / or date of the control.

[0110] B10. A loading system based on time-slicing, comprising:

[0111] The partitioning unit is used to divide at least two controls within the same frame into at least two groups of controls based on the system's refresh frame rate.

[0112] A storage unit is used to store the control group into a message queue with a preset priority;

[0113] An extraction drawing unit is used to extract the control group from the message queue according to the priority when the system screen refreshes, and draw the control group one by one on multiple consecutive frames.

[0114] B11. According to the loading system based on time-slice partitioning described in B10, the storage unit is specifically used for:

[0115] Each of the control groups is assembled into a message, and the message is stored in the message queue.

[0116] B12. According to the loading system based on time slices described in B11, the extraction and rendering unit includes:

[0117] The registration subunit is used to register a system refresh mechanism to listen for system screen refreshes;

[0118] An extraction subunit is used to extract a message from the message queue when the system screen refreshes;

[0119] A drawing subunit is used to perform function execution according to the content of the message to draw the control group one by one on multiple consecutive frames.

[0120] B13. According to the loading system based on time slices described in B12, the extraction and drawing unit is further used to send the extracted message to the main thread message processing of the system.

[0121] B14. The loading system based on time slices as described in B12 further includes a first detection unit, which is used to detect whether the message exists in the message queue;

[0122] The registration subunit is used to register the system refresh mechanism if the message exists.

[0123] B15. According to the time-slice-based loading system described in B11, the storage unit further includes:

[0124] An identifier subunit is used to identify a message ID for the assembled message;

[0125] The second detection unit is used to detect whether there is a message with the same ID in the message queue, and if so, to replace the message with the same message ID.

[0126] B16. The loading system based on time-slice partitioning as described in B11 further includes:

[0127] The flag setting unit is used to set a flag on the link that is refreshed by the system, and to determine whether a refresh is needed based on the flag.

[0128] A removal unit is used to remove the message from the message queue if a refresh is not required.

[0129] B17. According to the loading system based on time slices described in B10, the partitioning unit is specifically used for:

[0130] Based on the number of frames refreshed per second by the system, at least two controls within the same frame are divided into control groups with a number of groups less than or equal to the number of frames.

[0131] B18. The loading system based on time-slice partitioning as described in B10 further includes:

[0132] A configuration unit is used to configure the priority based on the type and / or date of the control.

[0133] C19. A storage medium for storing a computer program for executing any one of the time-slice-based loading methods in A1 to A9.

[0134] D20. A computer device, comprising a storage medium, a processor, and a computer program stored on the storage medium and executable on the processor, wherein the processor, when executing the computer program, implements the loading method based on time slices as described in any one of A1 to A9.

Claims

1. A loading method based on time slices, characterized in that, Applied to the Android system, including: Based on the number of frames refreshed per second by the system, at least two controls within the same frame are divided into control groups with a number of groups less than or equal to the number of frames. Each of the aforementioned control groups is assembled into a message, and the message is stored in a message queue; Register a system refresh mechanism to monitor system screen refreshes; When the system screen refreshes, the system refresh mechanism is called back to retrieve one of the messages from the message queue; Perform the function according to the content of the message to draw the control group one by one on multiple consecutive frames.

2. The loading method based on time slices according to claim 1, characterized in that, The step of the system refresh mechanism calling back to retrieve a message from the message queue when the system screen refreshes further includes: The extracted message is sent to the system's main thread message processing.

3. A loading system based on time-slice partitioning, characterized in that, Applied to the Android system, including: A partitioning unit is used to divide at least two controls within the same frame into control groups with a number of groups less than or equal to the number of frames, based on the number of frames refreshed per second by the system. A storage unit is used to assemble each of the control groups into a message and store the message in a message queue; An extraction drawing unit is used to extract the control group from the message queue when the system screen refreshes, and draw the control group one by one on multiple consecutive frames; The extraction and drawing unit includes: The registration subunit is used to register a system refresh mechanism to listen for system screen refreshes; An extraction subunit is used to extract a message from the message queue when the system screen refreshes; A drawing subunit is used to perform function execution according to the content of the message to draw the control group one by one on multiple consecutive frames.

4. The loading system based on time slices according to claim 3, characterized in that, The extraction and drawing unit is also used to send the extracted message to the system's main thread message processing.

5. A storage medium, characterized in that, Used to store a computer program for executing the loading method based on time slices as described in any one of claims 1 to 2.

6. A computer device comprising a storage medium, a processor, and a computer program stored on the storage medium and executable on the processor, characterized in that, When the processor executes the computer program, it implements the loading method based on time slices as described in any one of claims 1 to 2.

Images