A business processing method, apparatus, equipment and medium

Abstract

This specification discloses a business processing method, apparatus, device, and medium. The business processing method includes: after obtaining a cloud rendering request, establishing a target thread corresponding to the cloud rendering request, adding the target thread to the tail of a thread queue, and determining whether the thread load of the cloud rendering server has reached a thread load threshold; if so, determining the processing time point of the target thread based on the thread load threshold of the cloud rendering server and the number of threads preceding the target thread in the thread queue; when the processing time point of the target thread is reached, causing the cloud rendering server to process the target thread to provide cloud rendering services to the terminal that sent the cloud rendering request.

Description

Technical Field

[0001] This application relates to the field of computer technology, and in particular to a business processing method, apparatus, device and medium. Background Technology

[0002] In existing technologies, cloud rendering allows users to access resources via a web application or a local 3D program by clicking a "cloud rendering" button and using a high-speed internet connection. Commands are sent from the user terminal, the server executes the corresponding rendering task based on the command, and the rendered result is then sent back to the user terminal for display.

[0003] In view of this, a more efficient cloud rendering business processing solution is needed. Summary of the Invention

[0004] This specification provides a business processing method, apparatus, device, and medium to address the technical problem of how to perform cloud rendering business processing more efficiently.

[0005] To address the aforementioned technical problems, the embodiments in this specification provide the following technical solutions:

[0006] This specification provides an embodiment of a business processing method, including:

[0007] After obtaining the cloud rendering request, a target thread corresponding to the cloud rendering request is established, the target thread is added to the tail of the thread queue, and it is determined whether the thread load of the cloud rendering server has reached the thread load threshold.

[0008] If so, the processing time of the target thread is determined based on the thread load threshold of the cloud rendering server and the number of threads preceding the target thread in the thread queue.

[0009] When the processing time of the target thread is reached, the cloud rendering server processes the target thread to provide cloud rendering services to the terminal that sent the cloud rendering request.

[0010] Optionally, the method further includes:

[0011] Based on the waiting time of the target thread, recommendation information is determined, and during the waiting period of the target thread, the recommendation information is sent to the sending terminal of the cloud rendering request.

[0012] Optionally, the method further includes:

[0013] During the waiting period of the target thread, the processing time of the target thread is updated according to the thread processing status of the cloud rendering server.

[0014] Optionally, the thread processing of the cloud rendering server includes:

[0015] For any thread preceding the target thread, during the processing of that thread by the cloud rendering server, whether the terminal sending the cloud rendering request corresponding to that thread exits the cloud rendering service.

[0016] Optionally, the method further includes:

[0017] For any given thread, the duration for which cloud rendering services are provided to the sending terminal of the cloud rendering request corresponding to that thread is determined based on the level of the account that sent the cloud rendering request.

[0018] Optionally, the method further includes:

[0019] If the number of threads on the cloud rendering server does not meet the target, the cloud rendering server will process the target thread to provide cloud rendering services to the terminal that sent the cloud rendering request.

[0020] Optionally, the method further includes:

[0021] For any given thread, after the cloud rendering server has provided cloud rendering services to the sending terminal of the cloud rendering request corresponding to that thread for a preset duration, the cloud rendering server stops providing cloud rendering services to the sending terminal of the cloud rendering request corresponding to that thread, and provides cloud rendering services to the sending terminal of the cloud rendering request corresponding to the next thread in the thread queue.

[0022] This specification provides a business processing apparatus, including:

[0023] The judgment module is used to obtain a cloud rendering request, establish a target thread corresponding to the cloud rendering request, add the target thread to the tail of the thread queue, and determine whether the number of threads on the cloud rendering server has reached the thread load threshold.

[0024] The scheduling module is used to determine the processing time of the target thread if the number of threads on the cloud rendering server reaches the thread load threshold, based on the thread load threshold of the cloud rendering server and the number of threads preceding the target thread in the thread queue.

[0025] The execution module is used to cause the cloud rendering server to process the target thread when the processing time point of the target thread is reached, so as to provide cloud rendering services to the terminal that sent the cloud rendering request.

[0026] This specification provides an embodiment of a business processing device, including:

[0027] At least one processor;

[0028] as well as,

[0029] a memory communicatively coupled to the at least one processor;

[0030] in,

[0031] The memory stores instructions that can be executed by the at least one processor, which, when executed by the at least one processor, enables the at least one processor to perform the aforementioned business processing method.

[0032] This specification provides a computer-readable storage medium storing computer-executable instructions, which, when executed by a processor, implement the aforementioned business processing method.

[0033] The above-described at least one technical solution adopted in the embodiments of this specification can achieve the following beneficial effects:

[0034] The above technical solution can determine the thread queue, and execute each thread in the thread queue in sequence according to the thread load threshold of the cloud rendering server and the thread queue, thereby realizing the sequential processing of cloud rendering requests corresponding to each thread in the thread queue and improving the processing efficiency of cloud rendering services. Attached Figure Description

[0035] To more clearly illustrate the technical solutions in the embodiments of this specification or the prior art, the drawings used in the description of the embodiments of this specification or the prior art will be briefly introduced below. Obviously, the drawings described below are only some of the drawings that may be involved in the embodiments described in this specification. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0036] Figure 1 This is a schematic diagram of the execution entity of the business processing method in the first embodiment of this specification.

[0037] Figure 2 This is a flowchart illustrating the business processing method in the first embodiment of this specification.

[0038] Figure 3 This is a schematic diagram of the business processing device in the second embodiment of this specification. Detailed Implementation

[0039] To enable those skilled in the art to better understand the technical solutions in this specification, the technical solutions of the embodiments of this specification will be clearly and completely described below with reference to the accompanying drawings. Obviously, the embodiments described in this specification are merely some embodiments of this application, and not all embodiments. Based on the embodiments of this specification, all other embodiments obtained by those skilled in the art without creative effort should fall within the scope of protection of this application.

[0040] In existing technologies, cloud rendering allows users to access resources via a web application or a local 3D program by clicking a "cloud rendering" button and using a high-speed internet connection. Commands are sent from the user terminal, the server executes the corresponding rendering task based on the command, and the rendered result is then sent back to the user terminal for display.

[0041] The first embodiment of this specification (hereinafter referred to as "Embodiment 1") provides a business processing method. The executing entity of Embodiment 1 can be a terminal (including but not limited to mobile phones, computers, tablets, and televisions), a server, an operating system, an application, a business processing platform, or a business processing system, etc. That is, the executing entity can be diverse and can be set, used, or changed as needed. Alternatively, a third-party application can assist the executing entity in executing Embodiment 1. For example... Figure 1 As shown, the server can execute the business processing method in Embodiment 1, and a corresponding application can be installed on the terminal (held by the user). Data can be transmitted between the terminal or the application and the server. Data can be collected, input, or output, or pages or information can be processed (to the user) through the terminal or the application, thereby assisting the server in executing the business processing method in Embodiment 1.

[0042] like Figure 2 As shown, the business processing method provided in Embodiment 1 includes:

[0043] S101: (Execution subject) After obtaining the cloud rendering request, establish the target thread corresponding to the cloud rendering request, add the target thread to the tail of the thread queue, and determine whether the thread load of the cloud rendering server has reached the thread load threshold.

[0044] In Example 1, if a user has a cloud rendering service requirement (such as cloud rendering of advertising or game graphics), they can send a cloud rendering request to the cloud rendering server through a terminal (or an application on the terminal, such as a browser). This can be considered as the user initiating a cloud rendering service. For example, the user sends a cloud rendering request to the cloud rendering server by operating the relevant page or page button on the terminal. Of course, the user can initiate a cloud rendering service in accordance with existing technologies in order to send a cloud rendering request to the cloud rendering server.

[0045] The execution entity in Embodiment 1 can monitor whether the cloud rendering server receives a cloud rendering request. Alternatively, in addition to the cloud rendering server receiving cloud rendering requests sent by the terminal, the execution entity in Embodiment 1 can also receive cloud rendering requests sent by the terminal.

[0046] For example, the execution entity in Implementation Example 1 could be a cloud rendering server;

[0047] Alternatively, the execution entity of Embodiment 1 may include a cloud rendering server, so that the execution entity of Embodiment 1 can monitor whether the cloud rendering server obtains a cloud rendering request, or if the cloud rendering server obtains a cloud rendering request, the execution entity of Embodiment 1 also obtains the cloud rendering request.

[0048] Alternatively, the execution entity of Embodiment 1 may be part of the cloud rendering server (for example, the execution entity of Embodiment 1 may be a part of the cloud rendering server or a platform or system running on the cloud rendering server, etc., the same below), so that the execution entity of Embodiment 1 can monitor whether the cloud rendering server obtains the cloud rendering request, or the cloud rendering server can obtain the cloud rendering request through the execution entity of Embodiment 1.

[0049] Of course, the entity executing Example 1 can obtain cloud rendering requests through other means.

[0050] After the cloud rendering server receives the cloud rendering request, the execution entity of Embodiment 1 can establish the target thread corresponding to the cloud rendering request. Wherein, if the execution entity of Embodiment 1 includes the cloud rendering server, or is part of the cloud rendering server, then the establishment of the target thread corresponding to the cloud rendering request by the execution entity of Embodiment 1 may include: the execution entity of Embodiment 1 instructs the cloud rendering server to establish the thread corresponding to the cloud rendering request, denoted as the target thread.

[0051] The execution entity in Implementation Example 1 can maintain a thread pool; specifically, it can maintain a thread queue. In Implementation Example 1, a Spring Boot project can be created on the cloud rendering server using IntelliJ IDEA. This Spring Boot project communicates with the user terminal or its front-end browser via WebSocket. This Spring Boot project can serve as the execution entity of Implementation Example 1 or as part of it. After running, the Spring Boot project maintains the aforementioned thread pool or thread queue on the cloud rendering server.

[0052] In Example 1, after the execution entity establishes the target thread, it adds the target thread to the tail of the thread queue.

[0053] The execution entity in Example 1 can determine whether the thread load of the cloud rendering server (i.e., the number of threads the cloud rendering server is currently processing) meets the standard after the target thread is established. Generally, the cloud rendering server has a maximum number of threads that it can process simultaneously (let's call it the thread load threshold). If the thread load of the cloud rendering server reaches the maximum value, it is determined that the thread load of the cloud rendering server meets the standard; if the thread load of the cloud rendering server does not reach the maximum value, it is determined that the thread load of the cloud rendering server does not meet the standard, and the cloud rendering server still has idle thread processing resources and can process more threads.

[0054] S103: (Execution subject) If the number of threads on the cloud rendering server reaches the thread load threshold, then the processing time point of the target thread is determined based on the thread load threshold of the cloud rendering server and the number of threads before the target thread in the thread queue.

[0055] In Embodiment 1, each thread in the thread queue is a corresponding thread created by the execution entity of Embodiment 1 for each cloud rendering request it acquires. That is, each time the execution entity of Embodiment 1 acquires a cloud rendering request, it creates a thread corresponding to that cloud rendering request and adds that thread to the tail of the thread queue. If, after creating the thread corresponding to that cloud rendering request, the thread load of the cloud rendering server is insufficient, the execution entity of Embodiment 1 directly instructs the cloud rendering server to process the thread corresponding to that cloud rendering request, thereby providing cloud rendering services to the terminal that sent the cloud rendering request (i.e., the terminal that sent the cloud rendering request).

[0056] Accordingly, after the aforementioned target thread is established, if the number of threads on the cloud rendering server does not meet the target, the execution entity of Embodiment 1 will cause the cloud rendering server to process the target thread, and the cloud rendering server will provide cloud rendering services to the cloud rendering request sending terminal corresponding to the aforementioned target thread.

[0057] In Example 1, any thread corresponding to a cloud rendering request can be used as the target thread.

[0058] In Example 1, the cloud rendering server processes each thread in the thread queue sequentially according to their order, with threads ranked higher in the queue being processed first. After any thread in the thread queue has been processed, the execution entity in Example 1 removes that thread from the queue, and the thread following it fills its position or sequence number.

[0059] Assuming the maximum number of threads that the cloud rendering server can process simultaneously is n (n≥1), then for any cloud rendering request, if the thread corresponding to that cloud rendering request is in the first n positions of the thread queue after being added to the thread queue (indicating that the number of threads being processed by the cloud rendering server is less than n, and the thread load of the cloud rendering server is not up to standard), then the execution entity of Embodiment 1 can directly cause the cloud rendering server to process the thread corresponding to that cloud rendering request in order to provide cloud rendering services to the terminal that sent the cloud rendering request.

[0060] Correspondingly, if the target thread is located in the first n positions of the thread queue after being added to the thread queue, the execution entity of Embodiment 1 can directly enable the cloud rendering server to process the target thread in order to provide cloud rendering services to the cloud rendering request sending terminal corresponding to the target thread.

[0061] If the execution entity of Embodiment 1 establishes the target thread and determines that the number of threads on the cloud rendering server meets the standard, then the execution entity of Embodiment 1 determines the processing time point of the target thread based on the thread load threshold of the cloud rendering server and the number of threads preceding the target thread in the thread queue.

[0062] Following the previous example, if the target thread is located at the (i+1)th position (i≥n) in the thread queue after being added to the thread queue, it means that at least the first n threads in the thread queue are being processed by the cloud rendering server, and the thread load of the cloud rendering server has reached the standard. Then, the execution entity of Embodiment 1 determines the processing time point of the target thread as described above.

[0063] In Example 1, to ensure that each thread can efficiently and reasonably utilize cloud rendering resources, the cloud rendering server processes each thread for a preset duration. That is, for any given thread, the cloud rendering server provides cloud rendering services to the sending terminal of the cloud rendering request corresponding to that thread for a preset duration. After the preset duration has elapsed, the cloud rendering server stops providing cloud rendering services to the sending terminal of the cloud rendering request corresponding to that thread and begins providing cloud rendering services to the sending terminal of the next thread in the thread queue.

[0064] The following explains how to determine the processing time point of the target thread:

[0065] Continuing with the previous example, assume the maximum number of threads the cloud rendering server can handle simultaneously is n (n≥1), and the target thread, after being added to the thread queue, is located at the (i+1)th position in the thread queue (i≥n). This indicates that the cloud rendering server is processing n threads when the target thread is added to the thread queue. Assume the cloud rendering server is configured to provide a cloud rendering service of a preset duration T to the terminal sending the cloud rendering request corresponding to any thread, and that when the target thread is added to the thread queue, the n threads being processed by the cloud rendering server are x1 to xn.

[0066] Assume that when the target thread is added to the thread queue, the cloud rendering server has already provided a cloud rendering service of duration t1 to the terminal sending the cloud rendering request corresponding to thread x1, the cloud rendering server has already provided a cloud rendering service of duration t2 to the terminal sending the cloud rendering request corresponding to thread x2, and so on, until the cloud rendering server has provided a cloud rendering service of duration tn to the terminal sending the cloud rendering request corresponding to thread xn. Where t1, t2, ..., tn ≤ T.

[0067] For ease of explanation, let's assume the cloud rendering server has n thread channels. Each thread channel takes time T to process one thread at a time, and then processes the next thread after processing the previous one (corresponding to the thread load threshold of the cloud rendering server). Since the cloud rendering server needs to process the i threads preceding the target thread before it can process the target thread, let's assume that when the i threads preceding the target thread are processed, the number of threads processed by each thread channel are y1, y2, ..., yn, respectively. Then, y1 + y2 + ... + yn = i.

[0068] Based on the above assumptions, the time required from when the target thread is added to the thread queue to when the target thread is processed by a certain thread channel is [(T-t1)+T*y1]+[(T-t2)+T*y2]+……+[(T-tn)+T*yn]=T*n+T*i-(t1+t2+……+tn).

[0069] In this way, by adding the time required from when the target thread is added to the thread queue to when the target thread is processed by a certain thread channel, the processing time of the target thread can be obtained, that is, when the target thread starts processing.

[0070] In Example 1, for any thread, after the cloud rendering server provides cloud rendering services to the sending terminal of the cloud rendering request corresponding to that thread for a preset duration, it may still need a certain amount of time (let's call it T') to exit the connection with the sending terminal of the cloud rendering request corresponding to that thread before the next thread can be processed. Therefore, when determining the processing time point of the target thread, "T" can be replaced with "T+T'" accordingly. That is, the time required from when the target thread is added to the thread queue to when the target thread is processed by a certain thread channel (let's call it the waiting time of the target thread) is (T+T')*n+(T+T')*i-(t1+t2+……+tn).

[0071] In Example 1, after determining the waiting time or processing time of the target thread, the execution entity of Example 1 can send an instruction to the cloud rendering request sending terminal corresponding to the target thread, so that the cloud rendering request sending terminal corresponding to the target thread displays the waiting time or waiting countdown of the target thread.

[0072] In Example 1, based on the waiting time of the target thread, the execution entity of Example 1 can determine the recommended information and send the recommended information to the cloud rendering request sending terminal corresponding to the target thread during the target thread's waiting period (i.e., within the target thread's waiting time), so that the cloud rendering request sending terminal corresponding to the target thread displays the recommended information. The recommended information may be advertising information or other information, and may include one or more pieces of information, the total duration of which may be the waiting time of the target thread.

[0073] S105: When the (executing entity) reaches the processing time point of the target thread, the cloud rendering server processes the target thread to provide cloud rendering services to the sending terminal of the cloud rendering request.

[0074] When the processing time of the target thread is reached, the execution entity of Embodiment 1 can enable the cloud rendering server to process the target thread in order to provide cloud rendering services to the terminal that sent the cloud rendering request.

[0075] In Example 1, during the waiting period of the target thread (i.e., the waiting time of the target thread), the execution entity of Example 1 can update the processing time point of the target thread according to the thread processing status of the cloud rendering server. The thread processing status of the cloud rendering server can include the situation described in 1.1 or 1.2 (Example 1 is not limited to the situation described in 1.1 or 1.2):

[0076] 1.1 Reduced processing time

[0077] For any thread preceding the target thread, during the processing of that thread by the cloud rendering server, does the terminal sending the cloud rendering request corresponding to that thread exit the cloud rendering service? In other words, for any thread preceding the target thread in the thread queue, the cloud rendering server may not have provided cloud rendering service to the terminal sending the cloud rendering request corresponding to that thread for the preset duration, while the user actively terminates or exits the cloud rendering service. This falls under the category of "shortened processing time" in the cloud rendering server's thread processing scenarios.

[0078] In this way, the execution entity of Embodiment 1 needs to update the waiting time or processing time of the target thread. Generally speaking, if a user actively terminates or exits the cloud rendering service, thereby shortening the cloud rendering service originally preset to a duration of T to T1, the waiting time of the target thread will be shortened by "T-T1" accordingly, and the processing time of the target thread will be advanced by "T-T1" accordingly.

[0079] 1.2 Generally, cloud rendering requests are sent when an account is logged in on the terminal or the application on the terminal. Therefore, the sender of the cloud rendering request can be either the terminal or the application on the terminal, or a user account. In Example 1, for any thread, the execution entity of Example 1 determines the duration for which cloud rendering services are provided to the sending terminal of the cloud rendering request corresponding to that thread, based on the level of the sending account (generally the login account on the sending terminal or the login account of the application on the sending terminal). That is, under normal circumstances, the cloud rendering server provides cloud rendering services to the sending terminal of the cloud rendering request corresponding to any thread for a preset duration. However, depending on the level of the sending account of the cloud rendering request corresponding to that thread, the execution entity of Example 1 may determine that the duration for which cloud rendering services are provided to the sending terminal of the cloud rendering request corresponding to that thread is different from the preset duration. Generally, the higher the level of the sending account of the cloud rendering request corresponding to that thread, the longer the duration for which the cloud rendering server provides cloud rendering services to the sending terminal of the cloud rendering request corresponding to that thread. This belongs to the "processing extension" situation in the thread processing of the cloud rendering server.

[0080] In Example 1, if no changes occur that affect the preset duration of the cloud rendering service, the cloud rendering server will provide cloud rendering services to the sending terminal according to the preset duration as described above.

[0081] Therefore, the execution entity in Implementation Example 1 needs to update the waiting time or processing time of the target thread. Generally, if the processing time (i.e., cloud rendering service time) of any thread is extended by T2, the waiting time of the target thread will be extended by T2 accordingly, and the processing time of the target thread will be delayed by T2 accordingly.

[0082] In Example 1, a cloud rendering service is provided, in which a cloud rendering server performs rendering tasks and sends the rendered image to a sending terminal or an application on the sending terminal so that the sending terminal or the application on the sending terminal can display the rendered image.

[0083] In Example 1, the thread queue can be determined, and each thread in the thread queue is executed sequentially according to the thread load threshold of the cloud rendering server and the thread queue. This realizes the sequential processing of cloud rendering requests corresponding to each thread in the thread queue, thereby improving the processing efficiency of cloud rendering services.

[0084] In Implementation Example 1, the thread queue + synchronization lock (i.e., after the number of threads reaches the threshold, the processing of other threads is restricted) mechanism is used to meet the thread load threshold of the cloud rendering server as much as possible, maximize the use of the cloud rendering server's resources, and improve the processing efficiency of cloud rendering services. On the other hand, the "first-come, first-served" processing of threads is guaranteed, that is, the cloud rendering requests are processed "first-come, first-served", which ensures the fairness of cloud rendering service processing.

[0085] In Example 1, the duration for which the sending terminal provides cloud rendering server access is set to a preset duration to avoid cloud rendering resources being occupied by a single or a few terminals, thereby further improving the rationality and fairness of cloud rendering resource usage and increasing the efficiency of cloud rendering business processing.

[0086] In Example 1, by improving the rationality, fairness, and processing efficiency of cloud rendering services, cloud rendering server resources can be fully utilized to provide high-definition rendering services to more users, enabling users to achieve high-definition rendering effects simply through terminals or applications, thereby reducing the cost of using cloud rendering services for users.

[0087] like Figure 3 As shown, the second embodiment of this specification provides a business processing apparatus corresponding to the business processing method described in Embodiment 1, comprising:

[0088] The judgment module 202 is used to obtain a cloud rendering request, establish a target thread corresponding to the cloud rendering request, add the target thread to the tail of the thread queue, and determine whether the thread load of the cloud rendering server has reached the thread load threshold.

[0089] The scheduling module 204 is used to determine the processing time of the target thread if the number of threads on the cloud rendering server reaches the thread load threshold, based on the thread load threshold of the cloud rendering server and the number of threads preceding the target thread in the thread queue.

[0090] The execution module 206 is used to cause the cloud rendering server to process the target thread when the processing time point of the target thread is reached, so as to provide cloud rendering services to the sending terminal of the cloud rendering request.

[0091] Optionally, the device further includes:

[0092] The recommendation module is used to determine recommendation information based on the waiting time of the target thread, and send the recommendation information to the sending terminal of the cloud rendering request during the waiting period of the target thread.

[0093] Optionally, the scheduling module 204 is further configured to update the processing time of the target thread according to the thread processing status of the cloud rendering server during the waiting period of the target thread.

[0094] Optionally, the thread processing of the cloud rendering server includes:

[0095] For any thread preceding the target thread, during the processing of that thread by the cloud rendering server, whether the terminal sending the cloud rendering request corresponding to that thread exits the cloud rendering service.

[0096] Optionally, the scheduling module 204 is further configured to determine, for any given thread, the duration for providing cloud rendering services to the sending terminal of the cloud rendering request corresponding to that thread, based on the level of the sending account of the cloud rendering request corresponding to that thread.

[0097] Optionally, the execution module 206 is further configured to, if the number of threads on the cloud rendering server does not meet the target, cause the cloud rendering server to process the target thread in order to provide cloud rendering services to the terminal that sent the cloud rendering request.

[0098] Optionally, the execution module 206 is further configured to, for any thread, after the cloud rendering server has provided cloud rendering services to the cloud rendering request sending terminal corresponding to that thread for a preset duration, stop providing cloud rendering services to the cloud rendering request sending terminal corresponding to that thread, and provide cloud rendering services to the cloud rendering request sending terminal corresponding to the next thread in the thread queue.

[0099] The third embodiment of this specification provides a service processing device, including:

[0100] At least one processor;

[0101] as well as,

[0102] a memory communicatively coupled to the at least one processor;

[0103] in,

[0104] The memory stores instructions that can be executed by the at least one processor, which, when executed by the at least one processor, enables the at least one processor to perform the business processing method described in Embodiment 1.

[0105] The fourth embodiment of this specification provides a computer-readable storage medium storing computer-executable instructions, which, when executed by a processor, implement the business processing method described in Embodiment 1.

[0106] The above embodiments can be used in combination, and modules with the same name in different embodiments or within the same embodiment can be the same or different modules.

[0107] The foregoing has described specific embodiments of this specification; other embodiments are within the scope of the appended claims. In some cases, the actions or steps described in the claims may be performed in a different order than those shown in the embodiments and may still achieve the desired result. Furthermore, the processes depicted in the drawings do not necessarily have to follow the specific or sequential order shown to achieve the desired result. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.

[0108] The various embodiments in this specification are described in a progressive manner. Similar or identical parts between embodiments can be referred to mutually. Each embodiment focuses on describing the differences from other embodiments. In particular, the embodiments of apparatus, devices, and non-volatile computer-readable storage media are basically similar to the method embodiments, so the descriptions are relatively simple; relevant parts can be referred to the descriptions of the method embodiments.

[0109] The apparatus, device, non-volatile computer-readable storage medium and method provided in the embodiments of this specification are corresponding. Therefore, the apparatus, device and non-volatile computer storage medium also have similar beneficial technical effects as the corresponding method. Since the beneficial technical effects of the method have been described in detail above, the beneficial technical effects of the corresponding apparatus, device and non-volatile computer storage medium will not be repeated here.

[0110] In the 1990s, improvements to a technology could be clearly distinguished as either hardware improvements (e.g., improvements to the circuit structure of diodes, transistors, switches, etc.) or software improvements (improvements to the methodology). However, with technological advancements, many methodological improvements today can be considered direct improvements to the hardware circuit structure. Designers almost always obtain the corresponding hardware circuit structure by programming the improved methodology into the hardware circuit. Therefore, it cannot be said that a methodological improvement cannot be implemented using hardware physical modules. For example, a Programmable Logic Device (PLD) (such as a Field Programmable Gate Array (FPGA)) is such an integrated circuit whose logic function is determined by the user programming the device. Designers can program and "integrate" a digital system onto a PLD themselves, without needing chip manufacturers to design and manufacture dedicated integrated circuit chips. Furthermore, nowadays, instead of manually manufacturing integrated circuit chips, this programming is mostly implemented using "logic compiler" software. Similar to the software compiler used in program development, the original code before compilation must be written in a specific programming language, called a Hardware Description Language (HDL). There are many HDLs, such as ABEL (Advanced Boolean Expression Language), AHDL (Altera Hardware Description Language), Confluence, CUPL (Cornell University Programming Language), HDCal, JHDL (Java Hardware Description Language), Lava, Lola, MyHDL, PALASM, and RHDL (Ruby Hardware Description Language). Currently, the most commonly used are VHDL (Very-High-Speed ​​Integrated Circuit Hardware Description Language) and Verilog. Those skilled in the art should understand that by simply performing some logic programming on the method flow using one of these hardware description languages ​​and programming it into an integrated circuit, the hardware circuit implementing the logical method flow can be easily obtained.

[0111] The controller can be implemented in any suitable manner. For example, it can take the form of a microprocessor or processor and a computer-readable medium storing computer-readable program code (e.g., software or firmware) executable by the (micro)processor, logic gates, switches, application-specific integrated circuits (ASICs), programmable logic controllers, and embedded microcontrollers. Examples of controllers include, but are not limited to, the following microcontrollers: ARC 625D, Atmel AT91SAM, Microchip PIC18F26K20, and Silicon Labs C8051F320. A memory controller can also be implemented as part of the control logic of the memory. Those skilled in the art will also recognize that, in addition to implementing the controller in purely computer-readable program code form, the same functionality can be achieved by logically programming the method steps to make the controller take the form of logic gates, switches, application-specific integrated circuits, programmable logic controllers, and embedded microcontrollers. Therefore, such a controller can be considered a hardware component, and the means included therein for implementing various functions can also be considered as structures within the hardware component. Alternatively, the means for implementing various functions can be considered as both software modules implementing the method and structures within the hardware component.

[0112] The systems, devices, modules, or units described in the above embodiments can be implemented by computer chips or entities, or by products with certain functions. A typical implementation device is a computer. Specifically, a computer can be, for example, a personal computer, laptop computer, cellular phone, camera phone, smartphone, personal digital assistant, media player, navigation device, email device, game console, tablet computer, wearable device, or any combination of these devices.

[0113] For ease of description, the above devices are described in terms of function, divided into various units. Of course, in implementing this specification, the functions of each unit can be implemented in one or more software and / or hardware components.

[0114] Those skilled in the art will understand that the embodiments of this specification can be provided as methods, systems, or computer program products. Therefore, the embodiments of this specification can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the embodiments of this specification can take the form of a computer program product implemented on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0115] This specification is described with reference to the flowcharts and / or block diagrams of the methods, devices (systems), and computer program products according to the embodiments of this specification. It should be understood that each process and / or box in the flowchart and / or block diagram, as well as the combination of processes and / or boxes in the flowchart and / or block diagram, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing device to produce a machine, so that the instructions executed by the processor of the computer or other programmable data processing device generate instructions for implementing the processes in the flowchart and / or block diagram. Figure 1 a process or multiple processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0116] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 a process or multiple processes and / or boxes Figure 1 The function specified in one or more boxes.

[0117] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 a process or multiple processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0118] In a typical configuration, a computing device includes one or more processors (CPU), input / output interfaces, network interfaces, and memory.

[0119] Memory may include non-persistent storage in computer-readable media, such as random access memory (RAM) and / or non-volatile memory, such as read-only memory (ROM) or flash RAM. Memory is an example of computer-readable media.

[0120] Computer-readable media includes both permanent and non-permanent, removable and non-removable media that can store information using any method or technology. Information can be computer-readable instructions, data structures, modules of programs, or other data. Examples of computer storage media include, but are not limited to, phase-change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technologies, CD-ROM, digital versatile optical disc (DVD) or other optical storage, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other non-transferable medium that can be used to store information accessible by a computing device. As defined herein, computer-readable media does not include transient computer-readable media, such as modulated data signals and carrier waves.

[0121] It should also be noted that the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element.

[0122] This specification can be described in the general context of computer-executable instructions that are executed by a computer, such as program modules. Generally, program modules include routines, programs, objects, components, data structures, etc., that perform a specific task or implement a specific abstract data type. This specification can also be practiced in distributed computing environments, where tasks are performed by remote processing devices connected via a communication network. In distributed computing environments, program modules can reside in local and remote computer storage media, including storage devices.

[0123] The various embodiments in this specification are described in a progressive manner. Similar or identical parts between embodiments can be referred to interchangeably. Each embodiment focuses on describing the differences from other embodiments. In particular, the system embodiments are basically similar to the method embodiments, so the description is relatively simple; relevant parts can be referred to the descriptions in the method embodiments.

[0124] The above description is merely an embodiment of this specification and is not intended to limit this application. Various modifications and variations can be made to this application by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principle of this application should be included within the scope of the claims of this application.

Claims

1. A business processing method, comprising: After obtaining the cloud rendering request, a target thread corresponding to the cloud rendering request is established, the target thread is added to the tail of the thread queue, and it is determined whether the thread load of the cloud rendering server has reached the thread load threshold. If so, the processing time of the target thread is determined based on the thread load threshold of the cloud rendering server and the number of threads preceding the target thread in the thread queue. During the waiting period of the target thread, the processing time of the target thread is updated according to the thread processing status of the cloud rendering server; The thread processing status of the cloud rendering server includes at least one of the following: for any thread preceding the target thread, during the processing of the thread by the cloud rendering server, whether the sending terminal of the cloud rendering request corresponding to the thread exits the cloud rendering service. For any thread preceding the target thread, the duration of providing cloud rendering services to the sending terminal of the cloud rendering request corresponding to the thread is determined based on the level of the sending account of the cloud rendering request corresponding to the thread. When the processing time of the target thread is reached, the cloud rendering server processes the target thread to provide cloud rendering services to the terminal that sent the cloud rendering request.

2. The method of claim 1, further comprising: Based on the waiting time of the target thread, recommendation information is determined, and during the waiting period of the target thread, the recommendation information is sent to the sending terminal of the cloud rendering request.

3. The method of claim 1, further comprising: If the number of threads on the cloud rendering server does not meet the target, the cloud rendering server will process the target thread to provide cloud rendering services to the terminal that sent the cloud rendering request.

4. The method according to any one of claims 1 to 3, further comprising: For any given thread, after the cloud rendering server has provided cloud rendering services to the sending terminal of the cloud rendering request corresponding to that thread for a preset duration, the cloud rendering server stops providing cloud rendering services to the sending terminal of the cloud rendering request corresponding to that thread, and provides cloud rendering services to the sending terminal of the cloud rendering request corresponding to the next thread in the thread queue.

5. A business processing apparatus, comprising: The judgment module is used to obtain a cloud rendering request, establish a target thread corresponding to the cloud rendering request, add the target thread to the tail of the thread queue, and determine whether the number of threads on the cloud rendering server has reached the thread load threshold. The scheduling module is used to determine the processing time of the target thread if the number of threads on the cloud rendering server reaches the thread load threshold, based on the thread load threshold of the cloud rendering server and the number of threads preceding the target thread in the thread queue. During the waiting period of the target thread, the processing time of the target thread is updated according to the thread processing status of the cloud rendering server; The thread processing status of the cloud rendering server includes at least one of the following: for any thread preceding the target thread, during the processing of the thread by the cloud rendering server, whether the sending terminal of the cloud rendering request corresponding to the thread exits the cloud rendering service. For any thread preceding the target thread, the duration of providing cloud rendering services to the sending terminal of the cloud rendering request corresponding to the thread is determined based on the level of the sending account of the cloud rendering request corresponding to the thread. The execution module is used to cause the cloud rendering server to process the target thread when the processing time point of the target thread is reached, so as to provide cloud rendering services to the terminal that sent the cloud rendering request.

6. The apparatus of claim 5, further comprising: The recommendation module is used to determine recommendation information based on the waiting time of the target thread, and send the recommendation information to the sending terminal of the cloud rendering request during the waiting period of the target thread.

7. The apparatus of claim 5, wherein the execution module is further configured to, if the number of threads on the cloud rendering server does not meet the target, cause the cloud rendering server to process the target thread in order to provide cloud rendering services to the sending terminal of the cloud rendering request.

8. The apparatus as described in any one of claims 5 to 7, wherein the execution module is further configured to, for any thread, after the cloud rendering server provides cloud rendering services to the cloud rendering request sending terminal corresponding to the thread for a preset duration, stop providing cloud rendering services to the cloud rendering request sending terminal corresponding to the thread, and provide cloud rendering services to the cloud rendering request sending terminal corresponding to the next thread in the thread queue.

9. A business processing device, comprising: At least one processor; as well as, a memory communicatively coupled to the at least one processor; in, The memory stores instructions that can be executed by the at least one processor, which, when executed by the at least one processor, enables the at least one processor to perform the business processing method according to any one of claims 1 to 4.

10. A computer-readable storage medium storing computer-executable instructions that, when executed by a processor, implement the business processing method of any one of claims 1 to 4.

Images