An information processing method, apparatus, device, and storage medium

Abstract

The application provides an information processing method, device and equipment and a storage medium, the method comprising: receiving a plurality of task processing requests sent by a plurality of target objects, each task processing request carrying at least identification information of a corresponding target object; determining target task processing requests belonging to the same target object based on the identification information of the plurality of target objects; when the target task processing request is processed by a work thread, obtaining a target information storage block corresponding to the identification information carried in the target task processing request from a resource storage pool, the resource storage pool being determined based on serialization attribute information of services rented by the plurality of target objects; and performing a corresponding task operation in the target information storage block. In a serialization task processing scenario, the application allocates available resource quotas to each tenant according to the serialization capability of each tenant, ensures that each tenant uses at most one work thread for transaction processing, and effectively isolates the resources of multiple tenants.

Description

Technical Field

[0001] This invention belongs to the field of computer technology, and specifically relates to an information processing method, apparatus, device, and storage medium. Background Technology

[0002] In the internet era, microservices have become the mainstream architecture for backend technologies. Microservices decouple service logic, breaking it down into multiple lightweight sub-services. These services are interconnected through Remote Procedure Calls (RPCs), thereby reducing service complexity and improving maintainability and stability. However, with business growth and increased call volume, single-tenant systems can easily consume excessive resources, affecting overall service availability. This is especially true in enterprise service backends, where there are significant differences in enterprise size. Large enterprises may consume excessive server resources, leading to unbalanced resource allocation and impacting the user experience for other users.

[0003] Most existing multi-tenant isolation solutions are based on virtualization or container resource isolation strategies, which abstract a physical computer into multiple logical units, each running in an independent runtime environment, isolating physical resources such as CPU and memory to achieve multi-tenant resource isolation. However, this resource isolation strategy has a coarse-grained division and high isolation overhead. As the number of isolated partitions increases, the overall system performance degrades significantly. In enterprise-level Software as a Service (SaaS) application scenarios, a massive number of enterprises share online service resources, with significant differences in enterprise size. It is necessary to ensure the stable and reliable operation of each enterprise while preventing a single enterprise from consuming excessive service resources and affecting the normal operation of other enterprises' services. Therefore, multi-tenant resource isolation strategies based on virtualization or containers cannot meet the isolation needs of a massive number of enterprise tenants, and the coarse-grained isolation cannot meet the needs of refined enterprise service management and operation. Summary of the Invention

[0004] To avoid excessive resource consumption by a single tenant due to out-of-order execution of the same tenant in certain scenarios, this invention proposes an information processing method, apparatus, device, and storage medium. This is achieved by effectively allocating available resources to each tenant based on the current server resource status and the utilization of each tenant's resources. For example, in serialized task processing scenarios, each tenant is allocated a corresponding amount of available resources based on its serialization capability, ensuring that each tenant uses at most one worker thread.

[0005] On one hand, the present invention proposes an information processing method, the method comprising:

[0006] Receive multiple task processing requests sent by multiple target objects, wherein each of the multiple task processing requests carries at least the identification information corresponding to the identification information of the multiple target objects;

[0007] Based on the identification information of the multiple target objects, the target task processing request belonging to the same target object is determined from the multiple task processing requests;

[0008] When a target task processing request belonging to the same target object is processed by a worker thread, a target information storage block corresponding to the identification information carried in the target task processing request is obtained from the resource storage pool. The resource storage pool stores the first mapping relationship between the identification information and the information storage block. The resource storage pool is determined based on the serialization attribute information of the services leased by the multiple target objects.

[0009] Through a worker thread, the task operation corresponding to the target task processing request is executed in the target information storage block.

[0010] On the other hand, the present invention proposes an information processing apparatus, the apparatus comprising:

[0011] The receiving module is used to receive multiple task processing requests sent by multiple target objects, wherein each of the multiple task processing requests carries at least the identification information corresponding to the identification information of the multiple target objects.

[0012] The target task processing request determination module is used to determine the target task processing request belonging to the same target object from the multiple task processing requests based on the identification information of the multiple target objects;

[0013] The target information storage block acquisition module is used to acquire the target information storage block corresponding to the identification information carried in the target task processing request from the resource storage pool when the target task processing request belonging to the same target object is processed by a worker thread. The resource storage pool stores the mapping relationship between the identification information and the information storage block. The resource storage pool is determined based on the serialized attribute information of the application service rented by each target object.

[0014] The execution module is used to execute the task operation corresponding to the target task processing request in the target information storage block through the one working thread.

[0015] On the other hand, the present invention proposes an apparatus comprising: a processor and a memory, wherein the memory stores at least one instruction or at least one program, the at least one instruction or the at least one program being loaded and executed by the processor to implement the information processing method as described above.

[0016] On the other hand, the present invention proposes a computer-readable storage medium storing at least one instruction or at least one program, wherein the at least one instruction or the at least one program is loaded and executed by a processor to implement the information processing method as described above.

[0017] This invention proposes an information processing method, apparatus, device, and storage medium. In a serialized task processing scenario, when target task processing requests belonging to the same target object are processed by a single worker thread, an identification information storage pool and a resource storage pool can be pre-established based on the serialization attribute information of the services leased by each target object. When multiple task processing requests from multiple target objects are received, the identification information carried in the task processing requests determines whether the target task processing requests belong to the same target object. Then, the target task processing requests belonging to the same target object are hashed into the corresponding target information storage in the identification information storage pool and the resource storage pool. Finally, in the target information storage block, a worker thread executes the task operation corresponding to the target task processing request belonging to the same target object. This achieves effective allocation of available quotas to each tenant based on their serialization capabilities using a single worker thread, ensuring that in a serialized task processing scenario, a single tenant uses at most one worker thread to execute its sent task processing requests. This avoids excessive resource consumption by a single tenant due to out-of-order execution of the same tenant in certain scenarios, thereby achieving effective isolation of multi-tenant resources from the perspective of each tenant, reducing the impact of abnormal requests, and improving the overall system stability. Attached Figure Description

[0018] To more clearly illustrate the technical solutions and advantages in the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0019] Figure 1 This is a schematic diagram of the implementation environment of an information processing method provided in an embodiment of the present invention.

[0020] Figure 2 This is a flowchart illustrating an information processing method provided in an embodiment of the present invention in a serialized task processing scenario.

[0021] Figure 3 This is a schematic diagram illustrating the principle of data transmission between modules stored on the local terminal in the service provided by this embodiment of the invention.

[0022] Figure 4This is a typical RPC framework provided in the embodiments of the present invention.

[0023] Figure 5 This is a schematic diagram of a process for establishing a resource storage pool according to an embodiment of the present invention.

[0024] Figure 6 This is a schematic diagram of the structure of a serialized task queue and information storage block in a scenario provided by an embodiment of the present invention.

[0025] Figure 7 This is another flowchart illustrating the information processing method provided in this embodiment of the invention in a serialized task processing scenario.

[0026] Figure 8 This is a flowchart illustrating an information processing method provided in an embodiment of the present invention in a scenario with limited concurrency.

[0027] Figure 9 This is a schematic diagram of the counting buckets allocated to each tenant by the RPC framework in a concurrency-limited scenario, as provided in an embodiment of the present invention.

[0028] Figure 10 This is a schematic diagram illustrating the principle of delaying task processing through a delay queue in a concurrency-limited scenario, as provided by an embodiment of the present invention.

[0029] Figure 11 This is another flowchart illustrating the information processing method provided in this embodiment of the invention in a scenario with limited concurrency.

[0030] Figure 12 This is another flowchart illustrating the information processing method provided in this embodiment of the invention in a serialized task processing scenario.

[0031] Figure 13 This is a schematic diagram of a product interface in a scenario, illustrating an information processing method provided by an embodiment of the present invention.

[0032] Figure 14 This is a schematic diagram of the structure of an information processing device provided in an embodiment of the present invention.

[0033] Figure 15 This is a schematic diagram of the structure of a server provided in an embodiment of the present invention. Detailed Implementation

[0034] Cloud technology refers to a hosting technology that unifies a series of resources such as hardware, software, and networks within a wide area network or local area network to achieve data computing, storage, processing, and sharing.

[0035] Cloud technology is a general term encompassing network technology, information technology, integration technology, management platform technology, and application technology based on the cloud computing business model. It can form resource pools, providing flexible and convenient on-demand access. Cloud computing technology will become a crucial support. Backend services of technical network systems require substantial computing and storage resources, such as video websites, image websites, and many portal websites. With the rapid development and application of the internet industry, every item may have its own identification mark in the future, requiring transmission to backend systems for logical processing. Data at different levels will be processed separately, and various industry data will all require robust system support, which can only be achieved through cloud computing.

[0036] This invention relates to cloud network technology within cloud technology. Specifically, it relates to public cloud technology within cloud networks. Public cloud typically refers to a cloud provided by a third-party provider to users that is accessible through a network. Public clouds are generally available online and may be free or inexpensive. The core of a public cloud is shared resource services. There are many instances of such clouds, providing services across today's open public networks.

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

[0038] It should be noted that the terms "first," "second," etc., in the specification, claims, and accompanying drawings of this invention are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that the embodiments of the invention described herein can be implemented in orders other than those illustrated or described herein. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover non-exclusive inclusion; for example, a process, method, system, product, or server that comprises a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or devices.

[0039] Before introducing specific embodiments of the present invention, the technical terms involved in the present invention will be explained first.

[0040] Software as a Service (SaaS) is an application model that provides software services over the internet. Tenants rent software on demand, and typically one software can serve multiple tenants simultaneously. SaaS providers build all the network infrastructure, software, and hardware operating platforms needed for an enterprise's IT infrastructure, and are responsible for all pre-implementation and post-maintenance services. Enterprises can use the information system via the internet without purchasing hardware and software, building server rooms, or hiring technical personnel.

[0041] Remote Procedure Call (RPC) is a protocol that allows a program on a remote computer to request services over a network without needing to understand the underlying network technology. RPC assumes the existence of certain transport protocols, such as Transmission Control Protocol (TCP) or User Datagram Protocol (UDP), to carry information between communicating programs.

[0042] Tenant: A tenant refers to an organization or group of enterprises that subscribe to and use SaaS applications on demand. This can be an enterprise-level tenant or an individual-level tenant. User: A user is someone who directly uses the SaaS application, and a tenant can include multiple users. For example, if company A subscribes to SaaS application 1, then company A can be called a tenant of SaaS application 1, and company A's employees can be called users of SaaS application 1.

[0043] A circular queue is a queue whose storage space is arranged in a circular shape, with the last position of the queue wrapped around the first position, allowing for cyclical use. In a circular queue, when the last position is used and another element needs to be added, the first position only needs to be free; the first position is then used as the tail of the queue.

[0044] Figure 1 This is a schematic diagram illustrating the implementation environment of an information processing method provided in an embodiment of the present invention. For example... Figure 1 As shown, this implementation environment can include at least terminal 01 and server 02. In a SaaS application scenario, terminal 01 can be a tenant client, and server 02 can be used to provide SaaS services to tenants and perform secure isolation of multi-tenant data by tenant. Server 02 can include at least applications, a multi-tenant data isolation module, and a data storage module. Terminal 01 establishes a connection with server 02 via wired or wireless means to achieve data transmission between them through this network. For example, terminal 01 can send task processing requests to server 02 through this network.

[0045] Specifically, terminal 01 can be a smartphone, tablet computer, laptop computer, desktop computer, smart speaker, smartwatch, etc., but is not limited to these. Terminal 01 and server 02 can be directly or indirectly connected via wired or wireless communication, and this invention does not impose any limitations on this.

[0046] Specifically, server 02 can be an independent physical server, a server cluster or distributed system composed of multiple physical servers, or a cloud server that provides basic cloud computing services such as cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communication, middleware services, domain name services, security services, CDN, and big data and artificial intelligence platforms.

[0047] It should be noted that, Figure 1 This is just one example.

[0048] Figure 2 This is a flowchart illustrating an information processing method provided by an embodiment of the present invention. This specification provides the operational steps of the method described in the embodiments or flowcharts, but based on conventional or non-inventive methods, more or fewer operational steps may be included. The order of steps listed in the embodiments is merely one possible execution order among many and does not represent the only possible execution order. In actual system or server product execution, the method can be executed sequentially or in parallel (e.g., in a parallel processor or multi-threaded processing environment) as shown in the embodiments or drawings. Specifically, as shown... Figure 2 As shown, the method may include:

[0049] S101. Receive multiple task processing requests sent by multiple target objects, each of the multiple task processing requests carrying at least the identification information corresponding to the identification information of the multiple target objects.

[0050] S103. Based on the identification information of multiple target objects, determine the target task processing request that belongs to the same target object from multiple task processing requests.

[0051] In SaaS application scenarios, the target object can be either a tenant who needs to subscribe to use the SaaS application or a user within that tenant.

[0052] In this embodiment of the invention, taking the tenant of a SaaS application as an example, a globally unique ID number can be set for each tenant based on their registration information. For example, a unique identifier "a1" can be assigned to tenant A. Each user within each tenant can also have globally unique identifier information.

[0053] In this embodiment of the invention, when a tenant sends a task processing request to the server, the task processing request may directly carry the tenant's identification information, or information related to the tenant's identification information, or the specific task operation corresponding to the task processing request (e.g., login operation, access operation, transfer operation, etc.). After the server receives multiple task processing requests from multiple target objects, it can directly obtain the tenant's identification information or extract the corresponding identification information from information related to the tenant's identification information.

[0054] In addition, the terminal can save multiple task processing requests in data (cookies) stored on the local terminal and send the task processing requests along with the cookies to the server. The various modules of the server (e.g., module 1, module 2, module 3, module 4, module 5) can call and pass cookies. The cookie is issued by the server to the terminal in response to the terminal's request. The cookie is stored in the terminal, and the server can use the cookie to identify the tenant's identity or status. Figure 3 The diagram illustrates the principle of passing cookies between modules in the service. Because cookies are passed between modules, each backend module of the server can obtain the identification information of this task processing request, and use it as the identification granularity for multi-tenant resource isolation protection. The identification granularity is fine, which can provide a better multi-tenant resource isolation protection solution.

[0055] After storing multiple task processing requests in cookies, the server can distinguish online requests from different tenants based on the identification information carried in these requests. It can then categorize and summarize task processing requests with the same identification information to determine target task processing requests belonging to the same object. For example, in a SaaS application scenario, multiple tenants include tenant A, tenant B, and tenant C, and multiple task processing requests include request 1, request 2, request 3, request 4, request 5, and request 6. Requests 1 and 2 carry the identification information of tenant A, requests 3 and 4 carry the identification information of tenant B, and requests 5 and 6 carry the identification information of tenant C. Therefore, requests 1 and 2 belong to the same target task processing request for tenant A, requests 3 and 4 belong to the same target task processing request for tenant B, and requests 5 and 6 belong to the same target task processing request for tenant C.

[0056] S105. When a target task processing request belonging to the same target object is processed by a worker thread, the target information storage block corresponding to the identification information carried in the target task processing request is obtained from the resource storage pool. The resource storage pool stores the first mapping relationship between the identification information and the information storage block. The resource storage pool is determined based on the serialization attribute information of the business leased by multiple target objects.

[0057] In practical applications, for RPC services within a microservice architecture, the stable operation of the server depends on server resources, which can include at least a central processing unit (CPU), memory, network bandwidth, and the number of worker threads. A typical RPC framework can be as follows: Figure 4 As shown, the Input / Output (IO) threads are responsible for receiving requests and sending responses, while the Worker threads are responsible for processing business requests. The number of workers in a service is constant. If a tenant's request consumes too many worker threads, it will cause other tenants' or users' requests to not be processed in a timely manner. This can range from increasing processing time to causing frontend call timeouts and triggering a cascading failure. Similarly, CPU, memory, and network traffic have similar issues. If a single tenant or user consumes too many server processing resources, it will crowd out the processing resources of other tenants or users.

[0058] Based on this, taking a tenant whose target is a SaaS application as an example, in a serialized task processing scenario, Figure 4 The RPC framework in this context can leverage the serialization capabilities of each tenant. Specifically, it can allocate a batch of idle information storage blocks to each tenant based on the serialization attribute information of the services rented by each target object in the SaaS application. These idle data blocks are then connected using a circular queue, thereby pre-establishing a resource storage pool for allocating available resource quotas to each tenant. The "serialization attribute information of the services rented by each target object in the SaaS application" can be the execution order of the services rented by each target object that need to be executed sequentially (such as payment processing).

[0059] Specifically, such as Figure 5 As shown, establishing a resource storage pool can include:

[0060] S201. Based on the serialization attribute information of the services leased by each target object, determine the service serialization task queue corresponding to each target object.

[0061] Taking a tenant of a SaaS application as an example, in the scenario of serialized task processing within a SaaS application, a tenant may rent multiple services, such as payment and receipt services or email services. The functional modules within some services need to be executed serially (i.e., sequentially), such as payment and receipt services. Therefore, we can determine the tenant's corresponding serialized task queue based on the serialization attribute information of the rented services, specifically the order in which the functional modules within the service are executed. For example, taking the payment and receipt service as an example: assuming the execution order of the functional modules in the payment and receipt service is E1--E2--E3--E4--E5, this order constitutes the serialized task queue for the payment and receipt service. Since each tenant may rent multiple services, each tenant can also have multiple serialized task queues.

[0062] In SaaS applications with serialized task processing scenarios, a task management table can be used to manage the business serialized task queues corresponding to each tenant, and an independent mutex lock and queue head can be set for the business serialized task queue corresponding to the target object. Using mutex locks ensures that only one worker thread can execute the business serialized task queue corresponding to that tenant at any given time, standardizing the execution order and guaranteeing data security and integrity.

[0063] S203. Based on the business serialization task queue corresponding to each target object, allocate the corresponding information storage block to each target object.

[0064] S205. Connect the information storage blocks corresponding to each target object through a circular queue to obtain a resource storage pool.

[0065] S207. Establish a first mapping relationship between the identification information of each target object and the corresponding information storage block, and a second mapping relationship between the business serialization task queue and the corresponding information storage block, and store the first mapping relationship and the second mapping relationship in the resource storage pool.

[0066] In the serialized task processing scenario of SaaS applications, this embodiment of the invention can allocate corresponding idle information storage blocks to each target object according to the size and number of business serialized task queues corresponding to the target object. The idle information storage blocks allocated to each target object are then connected through a circular queue to obtain a resource storage pool. This resource storage pool stores a first mapping relationship between the identification information of each target object and its corresponding information storage block, and a second mapping relationship between the business serialized task queue and its corresponding information storage block. Since the resource storage pool is created based on the business serialized task queues obtained from each tenant, using this resource storage pool for data isolation results in finer-grained isolation and better isolation performance. Figure 6 The diagram shows the structure of a serialized task queue and resource storage pool in a scenario. Taking tenants A, B, and C as an example, the schematic diagram of the serialized task queues corresponding to tenants A, B, and C can be shown as follows. Figure 6 As shown in Figure A, a schematic diagram of the corresponding information storage block can be obtained as follows: Figure 6 As shown in B.

[0067] In the serialized task processing scenario of SaaS applications, this embodiment of the invention uses a circular queue to establish a resource storage pool, which can make full use of the circular queue to manage memory resources, prevent false overflows, improve memory allocation efficiency, reduce memory fragmentation, and increase the overall memory utilization rate.

[0068] Accordingly, such as Figure 7 As shown, S105 may include:

[0069] When a target task processing request belonging to the same target object is processed by a worker thread, the target information storage block corresponding to the identification information carried in the target task processing request is obtained from the resource storage pool based on the first mapping relationship.

[0070] In serialized task processing scenarios within SaaS applications, after identifying target task processing requests belonging to the same tenant, the corresponding target information storage block can be retrieved from the resource storage pool based on the first mapping relationship, corresponding to the identification information carried in the target task processing request. For example, if multiple tenants include tenant A, tenant B, and tenant C, then the target information storage block corresponding to the target task processing request belonging to the same tenant A can be determined, the target information storage block corresponding to the target task processing request belonging to the same tenant B can be determined, and the target information storage block corresponding to the target task processing request belonging to the same tenant C can be determined.

[0071] S107. Through a worker thread, execute the task operation corresponding to the target task processing request in the target information storage block.

[0072] In this embodiment of the invention, the following continues... Figure 7 As shown, S107 may include:

[0073] S107101. Based on the second mapping relationship, obtain the target business serialization task queue corresponding to the target information storage block from the resource storage pool.

[0074] S107103. Based on the serialized execution order of the task operations corresponding to the task processing request, hash the target task processing request to the target business serialized task queue.

[0075] S107105. Through a worker thread, execute the task operations corresponding to the target task processing requests in the target business serialized task queue in sequence.

[0076] In the serialized task processing scenario of SaaS applications, after determining the target information storage block, the corresponding target serialized task queue can be found in the resource storage pool according to the second mapping relationship. Then, according to the serialized execution order of the task operations corresponding to the task processing request, the target task processing request is hashed into the target business serialized task queue. Finally, the task operations corresponding to the target task processing request in the target business serialized task queue are executed in sequence. For example, tenant A sends a task processing request related to payment / receipt requests, including target task processing requests F1, F2, F3, F4, and F5 (assuming task operation E1 corresponds to request F1, task operation E2 to F2, task operation E3 to F3, task operation E4 to F4, and task operation E5 to F5). After receiving the above requests from tenant A, the server can hash the target task processing requests F1, F2, F3, F4, and F5 into the target business serialized task queue according to the serialized execution order of the task operations corresponding to the above requests. Finally, worker threads execute E1, E2, E3, E4, and E5 in sequence. After the worker thread has finished processing the tasks in the serialized task queue, the worker thread is recycled. Specifically, the worker thread can be recycled to the resource storage pool for subsequent requests to continue using. Recycling worker threads that have completed their tasks can effectively avoid out-of-order use of worker threads, reduce the impact of abnormal requests, and improve the overall stability of the system.

[0077] In this embodiment of the invention, a hash function can be used in the hashing process. A hash function is an algorithm (function) that takes a message of arbitrary length as input and outputs a hash value of fixed length. The data table that stores the hash values ​​is called a hash table. A hash table is a fast array for storing and reading elements. Its characteristic is that it can be used to locate and access the array based on the hash value of the data element. The hash functions used in this embodiment of the invention include, but are not limited to: Cyclic Redundancy Check (CRC), Message-Digest Algorithm (MSA), and Secure Hash Algorithm (SHA).

[0078] In SaaS application scenarios, in addition to the serialization described in S101-S107, Figure 4The RPC framework in the document can also limit the concurrency of tenants, that is, allocate a limited number of worker threads to each tenant, and use these limited number of worker threads to process task processing requests sent by the same tenant.

[0079] Specifically, such as Figure 8 As shown, when target task processing requests belonging to the same target object are processed by at least two worker threads, the method may further include:

[0080] S301. Receive multiple task processing requests sent by multiple target objects, each of the multiple task processing requests carrying at least the identification information corresponding to the identification information of the multiple target objects.

[0081] S303. Based on the identification information of multiple target objects, determine the target task processing request that belongs to the same target object from multiple task processing requests.

[0082] S305. Count the number of current worker threads that are simultaneously processing the target task processing request.

[0083] S307. When the number of current worker threads exceeds the first quantity threshold and a new worker thread requests to process the target task processing request, an error message is sent back to the target object to which the target task processing request belongs.

[0084] S309. When the number of current target worker threads is greater than or equal to 2 and less than or equal to the first quantity threshold, and a new worker thread requests to process the target task processing request, then the unprocessed target task processing request is processed by the new worker thread.

[0085] like Figure 9As shown, taking a tenant whose target object is a SaaS application as an example, in a concurrency limit scenario, the RPC framework allocates a counting bucket to each tenant, and the number in each counting bucket represents the tenant's concurrency. The tenant's concurrency refers to the number of target task processing requests sent by that tenant that the server processes simultaneously, i.e., the number of Worker threads used by the server to process these requests. Therefore, this counting bucket can be used to count the number of worker threads processing target task processing requests belonging to the same target object in S305. Before a Worker thread requests to execute a target task processing request sent by a tenant, the server checks the concurrency in the counting bucket corresponding to the tenant to which the target task processing request belongs. As described in S307, if the concurrency exceeds a first threshold, it indicates that the tenant is using too many Worker threads, and a special error code is returned to the tenant. As described in S309, if the concurrency does not exceed the first threshold, it indicates that the number of Worker threads used by the tenant has not yet reached the maximum concurrency limit, and a new Worker thread can be used to execute the unprocessed target task processing requests corresponding to that tenant. In addition, to accurately count the number of concurrent requests, the number of concurrent requests in the counting bucket can be increased before a new Worker thread executes the target task processing request, and decreased when the target task processing request finishes execution.

[0086] In practical applications, this first threshold can be set based on the size of the tenant or the frequency with which the services rented by the tenant in the SaaS application are invoked. This application does not limit the specific threshold setting method.

[0087] In one feasible embodiment, the rule for setting up the counting buckets can be as follows: Assuming there are 100,000 tenants, 1,000 counting buckets can be set up, allowing these 100,000 tenant IDs to share these 1,000 counting buckets. This method of sharing 1,000 counting buckets among 100,000 tenants reduces the excessive resource consumption caused by setting up a separate counting bucket for each tenant, effectively saving system resources.

[0088] In this embodiment of the invention, the above-mentioned concurrency limit protection measures are set at the RPC framework level, which effectively avoids a single large enterprise or abnormal user request from occupying too many worker threads of the service. It also allows for the manual setting of an appropriate number of concurrency based on the enterprise size, achieving resource isolation of worker threads between tenants with very low operating overhead, and effectively ensuring the overall stability of the service operation.

[0089] In one feasible implementation, concurrency limiting techniques can also be used in the message queue (MQ) component of the asynchronous queue infrastructure. When a target object (such as a tenant) has many asynchronous tasks (e.g., exceeding a preset asynchronous quantity threshold), the corresponding number of concurrent tasks will be high, impacting the backend service. A small number of abnormal accounts can affect a large number of normal accounts, increasing the impact. Based on this, a delayed queue can be established, such as... Figure 10 The diagram illustrates a principle of delaying task processing using a delay queue. Figure 10 As shown, the group replication plugin (MQMgr) in the message queue checks the current tenant's concurrent execution count (i.e., the number of worker threads currently processing target task processing requests belonging to that tenant) before dispatching each task processing request to a worker thread. If the concurrent execution count exceeds a second threshold, the task requests exceeding the second threshold are placed in a delayed queue. After the previous task of that tenant is completed, the task processing requests exceeding the second threshold are retrieved from the delayed queue and re-dispatched to the worker thread for execution.

[0090] Specifically, such as Figure 11 As shown, the method may further include;

[0091] S401. Receive multiple task processing requests sent by multiple target objects, each of the multiple task processing requests carrying at least the identification information corresponding to the identification information of the multiple target objects.

[0092] S403. Based on the identification information of multiple target objects, determine the target task processing request that belongs to the same target object from multiple task processing requests.

[0093] S405. When the number of asynchronous tasks corresponding to multiple target objects exceeds the asynchronous quantity threshold, count the number of current worker threads that are simultaneously processing the corresponding target task processing requests.

[0094] S407. When the number of current worker threads exceeds the second threshold, move unprocessed target task processing requests to the delayed queue.

[0095] S409. After the current worker thread finishes processing the corresponding target task processing request, the target task processing request in the delay queue is dispatched to the current worker thread for processing.

[0096] In practical applications, asynchronous tasks refer to tasks that first enter the "task queue". Once the "task queue" notifies the worker thread that a certain asynchronous task is ready to be executed, the asynchronous task will enter the worker thread and be executed by the corresponding worker thread.

[0097] Furthermore, the asynchronous quantity threshold and the second quantity threshold can be set according to the size of the tenant or the frequency of calls to the services rented by the tenant in the SaaS application. This application embodiment does not limit the specific threshold setting method.

[0098] It should be noted that there is no specific relationship between the second quantity threshold and the first quantity threshold. For example, in some scenarios, the second quantity threshold may be greater than or equal to the first threshold, while in other scenarios, the second quantity threshold may be less than the first threshold. This application does not impose specific limitations on this.

[0099] In this embodiment of the invention, by establishing a delayed queue, it is possible to prevent a single tenant from executing more tasks concurrently than the maximum concurrency limit, while also ensuring that all tasks are eventually executed.

[0100] In a feasible embodiment, the counting bucket can also be combined with MQ for concurrency limiting. That is, the method of using the counting bucket to count concurrency in S305-S309 is applied to S405. The counting bucket is used to count concurrency, and MQ is used to limit concurrency. This more effectively avoids a single large enterprise or abnormal user request occupying too many worker threads of the service. It achieves resource isolation of worker threads between tenants with very low operating overhead, effectively ensures the overall stability of the service operation, and ensures that all tasks are eventually executed.

[0101] In a feasible implementation, besides serialization and concurrency limits, CPU and memory are core system resources that significantly impact server stability. Based on this, the system calls made by each target object (e.g., tenant) before and after task execution can be calculated at the RPC framework level to obtain resource consumption information (e.g., memory and CPU runtime) of the current worker thread. This allows for the calculation of resource consumption information for the task operations corresponding to the target task processing request. When the resource consumption of a target ID exceeds a resource threshold, the weight of its corresponding target object is reduced (as described in S109-S1013 below).

[0102] In another feasible embodiment, when the server receives a task processing request sent by the target object again and the server load is relatively heavy (e.g., the load information is greater than the load threshold), the task processing request sent by the ID of the target object that consumes more resources is preferentially rejected (as described in S1012-S1018 below).

[0103] Specifically, taking a serialized task processing scenario as an example, such as Figure 12 As shown, after S107, the method may further include:

[0104] S109. Obtain the resource consumption information of the task operation corresponding to the execution target task processing request.

[0105] S1011. Based on the resource consumption information of the task operation corresponding to the target task processing request, determine the total resource consumption information of the target object to which the target task processing request belongs.

[0106] S1013. Reduce the weight of target objects whose total resource consumption information is greater than the resource threshold. The weight represents the priority of the server in processing task processing requests sent by the target object.

[0107] Specifically, after S1011, the method may also include:

[0108] S1012. Sort the target objects in reverse order according to the corresponding total resource consumption information to obtain a target object sequence.

[0109] S1014. Select the first preset number of target objects in the target object sequence as candidate objects.

[0110] S1016. When a task processing request is received again from a candidate object and the server's load information is greater than the load threshold, the task processing request sent by the candidate object is rejected.

[0111] S1018. When a task processing request is received again from a candidate object and the server's load information is less than or equal to the load threshold, continue to respond to the task processing request sent by the candidate object.

[0112] It should be noted that the methods for determining the above-mentioned resource consumption information and load information are also applicable to scenarios with limited concurrency.

[0113] In this embodiment of the invention, based on the system call statistics of the resources occupied by each tenant, for tenants with high resource consumption, their requests can be rejected during subsequent task processing according to the server load, thereby saving the performance overhead brought by virtualization or containerization, and well meeting the needs of enterprises or individuals for resource isolation and protection.

[0114] Figure 13 The diagram shown is a product interface illustration of an information processing method provided in this application embodiment in a specific scenario. The product can be a software-as-a-service related product, installed on a terminal for use by tenants renting the product. Specifically, as follows... Figure 13 Figure A shows the various functions under application management in this product. Figure 13 B shows the various functions under the management tools in this product, such as... Figure 13As shown in A and 13B, this Software as a Service provides tenants with various functions, including but not limited to payment and communication functions. Tenants can click on icons on the product interface according to their actual needs to generate task processing requests to be sent to the server. The server pre-divides into logical modules according to functions, with each logical module responsible for different functional requirements. Each logical module is deployed on multiple physical or virtual machines. After the server receives task processing requests from each tenant, it processes the task processing requests of each tenant simultaneously in multiple threads according to the method in the above embodiment, completing their respective functional logic.

[0115] The information processing method, apparatus, device, and storage medium provided in this embodiment of the invention are illustrated using a SaaS application tenant as an example. On one hand, because cookies are passed between different modules of the server, each backend module can obtain the identification information of this task processing request and use it as the identification granularity for multi-tenant resource isolation protection. The finer granularity provides a more effective multi-tenant resource isolation protection solution. On the other hand, in serialized task processing scenarios, a resource storage pool is pre-established based on the serialization attribute information of the services rented by each tenant, ensuring that at any given time, only one worker thread can execute the serialized task queue corresponding to that tenant's services, thus standardizing the execution order and ensuring... On the one hand, it ensures data security; on the other hand, in scenarios with limited concurrency, concurrency limit protection measures are set up at the RPC framework level to effectively prevent a single large enterprise or abnormal user request from occupying too many worker threads. This achieves resource isolation of worker threads between tenants with very low operating overhead, effectively ensuring the overall stability of the service. Furthermore, by establishing a delayed queue, it prevents a single tenant from executing tasks concurrently beyond the maximum concurrency limit while ensuring that all tasks are eventually executed. Additionally, for tenants with high resource consumption, their weight can be reduced, and in subsequent task processing, requests from tenants with high resource consumption can be preferentially rejected based on server load, thereby reducing server resource overhead. Through these aspects, this invention can avoid situations where a single tenant occupies too many resources due to out-of-order execution of the same tenant in certain scenarios. This achieves effective isolation of multi-tenant resources from the perspective of each tenant, reducing the impact of abnormal requests and improving the overall stability of the system.

[0116] like Figure 14 As shown, an embodiment of the present invention provides an information processing device, which may include:

[0117] The receiving module 501 can be used to receive multiple task processing requests sent by multiple target objects, wherein each of the multiple task processing requests carries at least the identification information corresponding to the identification information of the multiple target objects.

[0118] The target task processing request determination module 503 can be used to determine the target task processing request belonging to the same target object from multiple task processing requests based on the identification information of multiple target objects.

[0119] The target information storage block acquisition module 505 can be used to acquire the target information storage block corresponding to the identification information carried in the target task processing request from the resource storage pool when the target task processing request belonging to the same target object is processed by a worker thread. The resource storage pool stores the mapping relationship between the identification information and the information storage block. The resource storage pool is determined based on the serialized attribute information of the application service rented by each target object.

[0120] The execution module 507 can be used to execute the task operation corresponding to the target task processing request in the target information storage block through the aforementioned working thread.

[0121] In this embodiment of the invention, the device may further include a resource storage pool establishment module, which may include:

[0122] The business serialization task queue determination unit can be used to determine the business serialization task queue corresponding to each target object based on the serialization attribute information of the business leased by each target object.

[0123] The allocation unit can be used to allocate corresponding information storage blocks to each target object based on the business serialization task queue corresponding to each target object.

[0124] The connection unit can be used to connect the information storage blocks corresponding to various target objects through a circular queue to obtain a resource storage pool.

[0125] The establishment unit can be used to establish a first mapping relationship between the identification information of each target object and the corresponding information storage block, and a second mapping relationship between the business serialization task queue and the corresponding information storage block, and store the first mapping relationship and the second mapping relationship in the resource storage pool.

[0126] Specifically, the target information storage block acquisition module can be used to: based on the first mapping relationship, acquire the target information storage block corresponding to the identification information carried in the target task processing request from the resource storage pool.

[0127] Specifically, the execution module may include:

[0128] The target business serialization task queue acquisition unit can be used to acquire the target business serialization task queue corresponding to the target information storage block from the resource storage pool based on the second mapping relationship.

[0129] The hash unit can be used to hash the target task processing request to the target business serialized task queue based on the serialized execution order of the task operations corresponding to the task processing request.

[0130] The first execution unit can be used to sequentially execute the task operations corresponding to the target task processing requests in the target business serialized task queue through the aforementioned working thread.

[0131] In a feasible embodiment, when target task processing requests belonging to the same target object are processed by at least two worker threads, the apparatus may further include:

[0132] The first statistics module is used to count the number of current worker threads that are simultaneously processing the target task processing request.

[0133] The feedback module can be used to send error information to the target object to which the target task processing request belongs when the number of current worker threads exceeds a first quantity threshold and a new worker thread requests to process the target task processing request.

[0134] The processing module can be used to process unprocessed target task processing requests through a new worker process when the number of current target worker threads is greater than or equal to 2 and less than or equal to the first number threshold, and a new worker thread requests to process the target task processing request.

[0135] In one feasible embodiment, when target task processing requests belonging to the same target object are processed by at least two worker threads, the apparatus may further include:

[0136] The second statistics module can be used to count the number of current worker threads that are simultaneously processing the processing requests of the target tasks when the number of asynchronous tasks corresponding to multiple target objects is greater than the asynchronous quantity threshold.

[0137] The migration module can be used to migrate unprocessed target task processing requests to a delayed queue when the number of current worker threads exceeds a second threshold.

[0138] The dispatch module can be used to dispatch target task processing requests in the delay queue to the current worker thread for processing after the current worker thread has finished processing the corresponding target task processing request.

[0139] In one feasible embodiment, the device may further include:

[0140] The resource consumption information determination module can be used to obtain resource consumption information of the task operation corresponding to the execution target task processing request.

[0141] The total resource consumption information determination module can be used to determine the total resource consumption information of the target object to which the target task processing request belongs, based on the resource consumption information of the task operation corresponding to the execution target task processing request.

[0142] The weight reduction module can be used to reduce the weight of target objects whose total resource consumption information exceeds the resource threshold. The weight represents the priority of the server in processing task processing requests sent by the target object.

[0143] In one feasible embodiment, the device may further include:

[0144] The sorting module can be used to sort target objects in reverse order according to their corresponding total resource consumption information to obtain a sequence of target objects.

[0145] The candidate object determination module can be used to select the first preset number of target objects in the target object sequence as candidate objects.

[0146] The rejection response module can be used to reject a task processing request sent by a candidate object when the server's load information exceeds the load threshold and the candidate object is received again.

[0147] The Continue Response module can be used to continue responding to task processing requests sent by candidate objects when another task processing request is received and the server's load information is less than or equal to the load threshold.

[0148] It should be noted that the device embodiments provided in this invention are based on the same inventive concept as the method embodiments described above.

[0149] This invention also provides an electronic device for information processing, which includes a processor and a memory. The memory stores at least one instruction or at least one program. The processor loads and executes the at least one instruction or at least one program to implement the information processing method provided in the above method embodiments.

[0150] Embodiments of the present invention also provide a computer-readable storage medium that can be disposed in a terminal to store at least one instruction or at least one program related to implementing an information processing method in the method embodiments. The at least one instruction or at least one program is loaded and executed by a processor to implement the information processing method provided in the above method embodiments.

[0151] Optionally, in the embodiments of this specification, the storage medium may be located at at least one of the multiple network servers in a computer network. Optionally, in this embodiment, the storage medium may include, but is not limited to, various media capable of storing program code, such as USB flash drives, read-only memory (ROM), random access memory (RAM), portable hard drives, magnetic disks, or optical disks.

[0152] The memory described in this specification can be used to store software programs and modules. The processor executes various functional applications and data processing by running the software programs and modules stored in the memory. The memory may primarily include a program storage area and a data storage area. The program storage area may store the operating system, applications required for functions, etc.; the data storage area may store data created based on the use of the device, etc. Furthermore, the memory may include high-speed random access memory, and may also include non-volatile memory, such as at least one disk storage device, flash memory device, or other volatile solid-state storage device. Accordingly, the memory may also include a memory controller to provide the processor with access to the memory.

[0153] The information processing method embodiments provided in this invention can be executed on a terminal, computer terminal, server, or similar computing device. Taking running on a server as an example, Figure 15 This is a hardware structure block diagram of a server for an information processing method provided in an embodiment of the present invention. For example... Figure 15 As shown, the server 600 can vary significantly due to different configurations or performance. It may include one or more central processing units (CPUs) 610 (CPUs 610 may include, but are not limited to, microprocessors such as MCUs or programmable logic devices such as FPGAs), a memory 630 for storing data, and one or more storage media 620 (e.g., one or more mass storage devices) for storing application programs 623 or data 622. The memory 630 and storage media 620 may be temporary or persistent storage. The program stored in the storage media 620 may include one or more modules, each module including a series of instruction operations on the server. Furthermore, the CPU 610 may be configured to communicate with the storage media 620 and execute a series of instruction operations stored in the storage media 620 on the server 600. The server 600 may also include one or more power supplies 660, one or more wired or wireless network interfaces 650, one or more input / output interfaces 640, and / or one or more operating systems 621, such as Windows Server. TM Mac OS XTM Unix TM Linux TM FreeBSD TM etc.

[0154] The input / output interface 640 can be used to receive or send data via a network. Specific examples of the network described above may include a wireless network provided by the communication provider of server 600. In one example, the input / output interface 640 includes a network interface controller (NIC), which can connect to other network devices via a base station to communicate with the Internet. In another example, the input / output interface 640 may be a radio frequency (RF) module for wireless communication with the Internet.

[0155] Those skilled in the art will understand that Figure 15 The structure shown is for illustrative purposes only and does not limit the structure of the aforementioned electronic device. For example, server 600 may also include... Figure 15 The more or fewer components shown, or having the same Figure 15 The different configurations shown.

[0156] It should be noted that the order of the above embodiments of the present invention is merely for descriptive purposes and does not represent the superiority or inferiority of the embodiments. Furthermore, specific embodiments have been described above. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps described in the claims can be performed in a different order than that shown in the embodiments and still achieve the desired result. Additionally, the processes depicted in the drawings do not necessarily require a specific or sequential order to achieve the desired result. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.

[0157] 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 device and server embodiments 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.

[0158] Those skilled in the art will understand that all or part of the steps of the above embodiments can be implemented by hardware, or by a program instructing related hardware. The program can be stored in a computer-readable storage medium, such as a read-only memory, a disk, or an optical disk.

[0159] The above are merely preferred embodiments of the present invention and are not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

Claims

1. An information processing method, characterized in that, The method includes: Receive multiple task processing requests sent by multiple target objects, wherein each of the multiple task processing requests carries at least the identification information corresponding to the identification information of the multiple target objects; Based on the identification information of the multiple target objects, the target task processing request belonging to the same target object is determined from the multiple task processing requests; When a target task processing request belonging to the same target object is processed by a worker thread, a target information storage block corresponding to the identification information carried in the target task processing request is retrieved from the resource storage pool. The establishment process of the resource storage pool includes: determining the business serialization task queue corresponding to each target object based on the serialization attribute information of the business leased by each target object; allocating corresponding information storage blocks to each target object based on the business serialization task queue corresponding to each target object; connecting the information storage blocks corresponding to each target object through a circular queue to obtain the resource storage pool; establishing a first mapping relationship between the identification information of each target object and the corresponding information storage block and a second mapping relationship between the business serialization task queue and the corresponding information storage block, and storing the first mapping relationship and the second mapping relationship in the resource storage pool. Through a worker thread, the task operation corresponding to the target task processing request is executed in the target information storage block.

2. The method according to claim 1, characterized in that, The step of retrieving the target information storage block from the resource storage pool corresponding to the identification information carried in the target task processing request includes: Based on the first mapping relationship, a target information storage block corresponding to the identification information carried in the target task processing request is obtained from the resource storage pool; Accordingly, the step of executing the task operation corresponding to the target task processing request in the target information storage block through the aforementioned worker thread includes: Based on the second mapping relationship, the target business serialization task queue corresponding to the target information storage block is obtained from the resource storage pool; Based on the serialized execution order of the task operations corresponding to the task processing request, the target task processing request is hashed into the target business serialized task queue; Through a single worker thread, the task operations corresponding to the target task processing requests in the target business serialized task queue are executed sequentially.

3. The method according to claim 1, characterized in that, When target task processing requests belonging to the same target object are processed by at least two worker threads, after determining the target task processing requests belonging to the same target object from the multiple task processing requests based on the identification information of the multiple target objects, the method further includes: Count the number of currently working threads that are simultaneously processing the target task processing request; When the number of current worker threads exceeds a first number threshold and a new worker thread requests to process the target task processing request, an error message is sent back to the target object to which the target task processing request belongs. When the number of current target worker threads is greater than or equal to 2 and less than or equal to the first number threshold, and a new worker thread requests to process the target task processing request, then the unprocessed target task processing request is processed by the new worker thread.

4. The method according to claim 1, characterized in that, When target task processing requests belonging to the same target object are processed by at least two worker threads, after determining the target task processing requests belonging to the same target object from the multiple task processing requests based on the identification information of the multiple target objects, the method further includes: When the number of asynchronous tasks corresponding to the multiple target objects exceeds the asynchronous quantity threshold, the number of current worker threads that are simultaneously processing the target task processing requests is counted. When the number of current working threads exceeds the second threshold, unprocessed target task processing requests are moved to the delayed queue; After the current working thread finishes processing the corresponding target task processing request, the target task processing request in the delay queue is dispatched to the current working thread for processing.

5. The method according to claim 1, characterized in that, After executing the task operation corresponding to the target task processing request in the target information storage block, the method further includes: Obtain the resource consumption information of the task operation corresponding to the execution of the target task processing request; Based on the resource consumption information of the task operation corresponding to the target task processing request, determine the total resource consumption information of the target object to which the target task processing request belongs; The weight of target objects whose total resource consumption information exceeds a resource threshold is reduced, whereby the weight represents the priority of the server in processing task processing requests sent by the target object.

6. The method according to claim 5, characterized in that, After determining the total resource consumption information of the target object to which the target task processing request belongs, the method further includes: The target objects are sorted in reverse order according to their corresponding total resource consumption information to obtain a target object sequence. The first preset number of target objects in the target object sequence are selected as candidate objects; If a task processing request is received again from the candidate object and the server's load information is greater than the load threshold, the task processing request sent by the candidate object will be rejected. When a task processing request is received again from the candidate object and the server's load information is less than or equal to the load threshold, the server continues to respond to the task processing request sent by the candidate object.

7. An information processing device, characterized in that, The device includes: The receiving module is used to receive multiple task processing requests sent by multiple target objects, wherein each of the multiple task processing requests carries at least the identification information corresponding to the identification information of the multiple target objects. The target task processing request determination module is used to determine the target task processing request belonging to the same target object from the multiple task processing requests based on the identification information of the multiple target objects; The target information storage block acquisition module is used to acquire the target information storage block corresponding to the identification information carried in the target task processing request from the resource storage pool when a target task processing request belonging to the same target object is processed by a worker thread. The execution module is used to execute the task operation corresponding to the target task processing request in the target information storage block through the one working thread; Resource storage pool establishment module, the resource storage pool establishment module includes: The business serialization task queue determination unit is used to determine the business serialization task queue corresponding to each target object based on the serialization attribute information of the business leased by each target object. The allocation unit is used to allocate corresponding information storage blocks to each target object based on the business serialization task queue corresponding to each target object. A connection unit is used to connect the information storage blocks corresponding to each target object through a circular queue to obtain the resource storage pool; The establishment unit is used to establish a first mapping relationship between the identification information of each target object and the corresponding information storage block, and a second mapping relationship between the business serialization task queue and the corresponding information storage block, and to store the first mapping relationship and the second mapping relationship in the resource storage pool.

8. The apparatus according to claim 7, characterized in that, The target information storage block acquisition module is used for: Based on the first mapping relationship, a target information storage block corresponding to the identification information carried in the target task processing request is obtained from the resource storage pool; Accordingly, the execution module includes: The target service serialization task queue acquisition unit is used to acquire the target service serialization task queue corresponding to the target information storage block from the resource storage pool based on the second mapping relationship. A hash unit is used to hash the target task processing request to the target business serialized task queue based on the serialized execution order of the task operations corresponding to the task processing request. The first execution unit is used to sequentially execute the task operations corresponding to the target task processing requests in the target business serialized task queue through the one working thread.

9. The apparatus according to claim 7, characterized in that, When target task processing requests belonging to the same target object are processed by at least two worker threads, the apparatus further includes: The first statistics module is used to count the number of current worker threads that are simultaneously processing the target task processing request; The feedback module is used to send error information to the target object to which the target task processing request belongs when the number of current worker threads is greater than a first number threshold and a new worker thread requests to process the target task processing request. The processing module is configured to process unprocessed target task processing requests through the new worker thread when the number of current target worker threads is greater than or equal to 2 and less than or equal to the first number threshold, and a new worker thread requests to process the target task processing request.

10. The apparatus according to claim 7, characterized in that, When target task processing requests belonging to the same target object are processed by at least two worker threads, the apparatus further includes: The second statistics module is used to count the number of current worker threads that are simultaneously processing the target task processing requests when the number of asynchronous tasks corresponding to the multiple target objects is greater than the asynchronous number threshold. The migration module is used to migrate unprocessed target task processing requests to a delayed queue when the number of current working threads exceeds a second threshold. The dispatch module is used to dispatch the target task processing request in the delay queue to the current working thread for processing after the current working thread has finished processing the corresponding target task processing request.

11. The apparatus according to claim 7, characterized in that, The device also includes; The resource consumption information determination module is used to obtain resource consumption information of the task operation corresponding to the execution of the target task processing request; The total resource consumption information determination module is used to determine the total resource consumption information of the target object to which the target task processing request belongs, based on the resource consumption information of the task operation corresponding to the execution of the target task processing request. The weight reduction module is used to reduce the weight of target objects whose total resource consumption information is greater than a resource threshold. The weight represents the priority of the server in processing task processing requests sent by the target object.

12. The apparatus according to claim 11, characterized in that, The device further includes: The sorting module is used to sort the target objects in reverse order according to the corresponding total resource consumption information to obtain a target object sequence. The candidate object determination module is used to select the first preset number of target objects in the target object sequence as candidate objects; The rejection response module is used to reject the task processing request sent by the candidate object when the server's load information is greater than the load threshold after receiving the task processing request sent by the candidate object again. The continued response module is used to continue responding to the task processing request sent by the candidate object when it receives the task processing request again and the load information of the server is less than or equal to the load threshold.

13. An electronic device, characterized in that, The electronic device includes a processor and a memory, the memory storing at least one instruction or at least one program, the at least one instruction or the at least one program being loaded and executed by the processor to implement the information processing method as described in any one of claims 1 to 6.

14. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores one or more computer-readable storage media, characterized in that the computer-readable storage medium stores at least one instruction or at least one program, the at least one instruction or the at least one program being loaded and executed by a processor to implement the information processing method as described in any one of claims 1 to 6.

Images