CN111078436A

CN111078436A - Data processing method, device, equipment and storage medium

Info

Publication number: CN111078436A
Application number: CN201911312673.XA
Authority: CN
Inventors: 夏之春; 刘艳云; 胡闻涛
Original assignee: Shanghai Kingstar Fintech Co Ltd
Current assignee: Shanghai Kingstar Fintech Co Ltd
Priority date: 2019-12-18
Filing date: 2019-12-18
Publication date: 2020-04-28
Anticipated expiration: 2039-12-18
Also published as: CN111078436B

Abstract

The application is applicable to the technical field of computers, and provides a data processing method, which comprises the following steps: in response to a plurality of user instructions sent by a plurality of terminal devices, the user instructions are put into a first data queue of a scheduling thread corresponding to the user instruction category, and then the user instructions in the first data queue are put into a second data queue of a coroutine corresponding to a user in the scheduling thread; and traversing the coroutines to be scheduled by the scheduling thread, carrying out calling-in operation on the coroutines if the currently traversed coroutines to be scheduled meet calling-in conditions, and carrying out calling-out operation on the coroutines if the called-in coroutines meet calling-out conditions. The data processing efficiency close to parallel processing can be realized by fully utilizing the processor resources through the steps.

Description

Data processing method, device, equipment and storage medium

Technical Field

The present application belongs to the field of computer technologies, and in particular, to a method, an apparatus, a device, and a storage medium for data processing.

Background

In many financial systems, the remote synchronous call mode is very common, i.e. the call programming of requests and responses is almost unavoidable, often requiring long waiting times in waiting for responses. For example, in the development practice of futures financial transaction terminals, an original mature remote invocation scenario, for example, an online transaction scenario, is a typical case where the synchronous invocation and the request response delay are large. In the scene, each user has exclusive ownership of a transaction connection and calling channel, and remote back-and-forth interaction of a common instruction is in millisecond level. Under the appeal of programmed transaction, a transaction party needs to drive a plurality of user accounts at the same time to perform simultaneous transaction at one terminal or policy party. In consideration of the real-time requirement of the algorithm, a plurality of user instructions are required to be sent and interacted simultaneously, and therefore, the mode of sending the user instructions serially through a single thread cannot meet the efficiency requirement of the algorithm. In many software schemes for financial application, in consideration of the security, the stability, the novelty and the reliability of a system, the transformation difficulty and the cost for realizing the multithreading concurrent data processing by reconstructing a communication layer or a deep reconstruction software parallel processing architecture are high, so that a scheme for realizing the parallel processing of a plurality of user instructions at low cost on the basis of the existing system architecture is needed.

Disclosure of Invention

Embodiments of the present application provide a method, an apparatus, a device, and a storage medium for data processing, which can solve at least part of the above problems.

In a first aspect, an embodiment of the present application provides a data processing method, including:

responding to a plurality of user instructions sent by a plurality of terminal devices, and adding the user instructions into a first data queue of a target scheduling thread according to the category of each user instruction; the target scheduling thread is a scheduling thread corresponding to the category of the user instruction in a plurality of scheduling threads;

adding the user instruction into a second data queue of the target coroutine according to the user identification in the user instruction in the first data queue aiming at the first data queue of each target scheduling thread; the target coroutine is a coroutine corresponding to the user identifier in a plurality of coroutines to be called of the target scheduling thread;

respectively traversing the coroutines to be called of each target scheduling thread;

if the currently traversed coroutine to be called meets calling-in conditions, determining the coroutine to be called as an active coroutine; executing call-in operation on the active coroutine, and processing a user instruction in the second data queue of the active coroutine;

if the active coroutine is determined to finish processing a user instruction, adding a processing result into a response queue of a response thread; according to the user identification of the processing result, sequentially feeding back the processing result in the response team to the terminal equipment corresponding to the user identification;

and if the movable coroutine meets at least one of the plurality of calling conditions, executing calling operation on the movable coroutine, suspending the movable coroutine, and saving the current processing position of the coroutine as a calling position.

It can be understood that, by classifying the user instructions sent by the user and processing the user instructions of the individual categories by the thread scheduling routines corresponding to the respective categories, the execution time of each user instruction in one scheduling routine can be relatively averaged; furthermore, the co-program is scheduled by the scheduling thread, so that processor resources can be fully utilized, and the effect of approximate parallel processing is achieved, thereby improving the data processing efficiency.

In a second aspect, an embodiment of the present application provides an apparatus for data processing, including:

the first data allocation module is used for responding to a plurality of user instructions sent by a plurality of terminal devices and adding the user instructions into a first data queue of a target scheduling thread according to the category of each user instruction; the target scheduling thread is a scheduling thread corresponding to the category of the user instruction in a plurality of scheduling threads;

a second data allocation module, configured to add, for the first data queue of each target scheduling thread, a user instruction to a second data queue of a target coroutine according to a user identifier in the user instruction in the first data queue; the target coroutine is a coroutine corresponding to the user identifier in a plurality of coroutines to be called of the target scheduling thread;

the traversal module is used for respectively traversing the coroutines to be called of each target scheduling thread;

the call-in module is used for determining the coroutine to be called as an active coroutine if the currently traversed coroutine to be called meets call-in conditions; executing call-in operation on the active coroutine, and processing a user instruction in the second data queue of the active coroutine;

the output module is used for adding a processing result into a response queue of a response thread if the active coroutine is determined to finish processing a user instruction; according to the user identification of the processing result, sequentially feeding back the processing result in the response team to the terminal equipment corresponding to the user identification;

and the call-out module is used for executing call-out operation on the active coroutine if the active coroutine is determined to meet at least one of a plurality of call-out conditions, suspending the active coroutine and saving the current processing position of the coroutine as a call-out position.

In a third aspect, an embodiment of the present application provides a data processing apparatus, including:

comprising a memory, a processor and a computer program stored in said memory and executable on said processor, said computer program realizing the method steps of the first aspect described above when executed by said processor.

In a fourth aspect, an embodiment of the present application provides a computer-readable storage medium, including: the computer readable storage medium stores a computer program which, when executed by a processor, performs the method steps of the first aspect described above.

Fifth aspect embodiments provide a computer program product, which when run on a data processing apparatus causes the data processing apparatus to perform the method steps of the first aspect.

It is understood that the beneficial effects of the second aspect to the fifth aspect can be referred to the related description of the first aspect, and are not described herein again.

Drawings

In order to more clearly illustrate the technical solutions in the embodiments of the present application, the drawings needed to be used in the embodiments or the prior art descriptions will be briefly described below, and it is obvious that the drawings in the following description are only some embodiments of the present application, and it is obvious for those skilled in the art to obtain other drawings based on these drawings without inventive exercise.

FIG. 1 is a schematic diagram of a system for providing a financial transaction system according to an embodiment of the present application;

FIG. 2 is a schematic flow chart diagram illustrating a method for data processing according to an embodiment of the present application;

FIG. 3 is a schematic data flow diagram illustrating a method of data processing according to an embodiment of the present application;

FIG. 4 is a schematic structural diagram of a data processing apparatus according to an embodiment of the present disclosure;

fig. 5 is a schematic structural diagram of a data processing device according to an embodiment of the present application.

Detailed Description

In the following description, for purposes of explanation and not limitation, specific details are set forth, such as particular system structures, techniques, etc. in order to provide a thorough understanding of the embodiments of the present application. It will be apparent, however, to one skilled in the art that the present application may be practiced in other embodiments that depart from these specific details. In other instances, detailed descriptions of well-known systems, devices, circuits, and methods are omitted so as not to obscure the description of the present application with unnecessary detail.

It will be understood that the terms "comprises" and/or "comprising," when used in this specification and the appended claims, specify the presence of stated features, integers, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof.

It should also be understood that the term "and/or" as used in this specification and the appended claims refers to and includes any and all possible combinations of one or more of the associated listed items.

As used in this specification and the appended claims, the term "if" may be interpreted contextually as "when", "upon" or "in response to" determining "or" in response to detecting ". Similarly, the phrase "if it is determined" or "if a [ described condition or event ] is detected" may be interpreted contextually to mean "upon determining" or "in response to determining" or "upon detecting [ described condition or event ]" or "in response to detecting [ described condition or event ]".

Furthermore, in the description of the present application and the appended claims, the terms "first," "second," "third," and the like are used for distinguishing between descriptions and not necessarily for describing or implying relative importance.

Reference throughout this specification to "one embodiment" or "some embodiments," or the like, means that a particular feature, structure, or characteristic described in connection with the embodiment is included in one or more embodiments of the present application. Thus, appearances of the phrases "in one embodiment," "in some embodiments," "in other embodiments," or the like, in various places throughout this specification are not necessarily all referring to the same embodiment, but rather "one or more but not all embodiments" unless specifically stated otherwise. The terms "comprising," "including," "having," and variations thereof mean "including, but not limited to," unless expressly specified otherwise.

In many financial systems, the remote synchronous call mode is very common, i.e. the call programming of requests and responses is almost unavoidable, often requiring long waiting times in waiting for responses. For example, in the development practice of futures financial transaction terminals, an original mature remote invocation scenario, for example, an online transaction scenario, is a typical case where the synchronous invocation and the request response delay are large. In the scene, each user has exclusive ownership of a transaction connection and calling channel, and remote back-and-forth interaction of a common instruction is in millisecond level. Under the appeal of programmed transaction, a transaction party needs to drive a plurality of user accounts at the same time to perform simultaneous transaction at one terminal or policy party. In consideration of the real-time requirement of the algorithm, a plurality of user instructions are required to be sent and interacted simultaneously, and therefore, the mode of sending the user instructions serially through a single thread cannot meet the efficiency requirement of the algorithm. In many software schemes applied to finance, the transformation difficulty and the cost for realizing the multithreading concurrent data processing through a reconstruction software architecture of a reconstruction communication layer or depth are high in consideration of the safety, stability, novelty and reliability of a system. Therefore, a solution for realizing parallel processing of multiple user instructions at low cost based on the existing system architecture is needed.

In order to solve at least part of the above problems, embodiments of the present application provide a data processing method, where on one hand, various user instructions are added to corresponding categories of threads for processing by classifying a plurality of received user instructions sent by a plurality of terminal devices, for example, instructions classified into categories of transaction instructions and query instructions, so that one thread processes only one type of user instruction, thereby reducing complexity of thread processing. On the other hand, in each thread, the user instruction of the corresponding user is processed through the coroutine example corresponding to the user identifier, and each thread schedules the coroutines in the thread and corresponding to the user, such as timely calling-out operation, so that the coroutines waiting for the remote service response message do not occupy thread resources, the utilization rate of computing resources of the system is improved, the cost is reduced, and the user experience is improved. On the other hand, concurrent data processing is realized through scheduling of the coroutine by the scheduling thread, so that large-range modification of a financial system software architecture is avoided, and the stability and reliability of the system are ensured.

The following description is made with reference to the accompanying drawings.

Fig. 1 illustrates a financial transaction system provided in an embodiment of the present application, including: a plurality of terminals 110, a data processing device 120, and a plurality of remote service devices 130.

Wherein the terminal device 110 and the data processing device 120 are connected through a wired and/or wireless communication network; and the terminal equipment and the data processing equipment perform user instructions, user instruction processing results and data interaction to finish user operations of the financial system such as inquiry, transaction and the like.

Wherein the data processing device 120 and the remote service device 130 are connected through a wired and/or wireless communication network; and performing data interaction between the data processing equipment and the remote service equipment so that the data processing equipment can process the user instruction sent by the terminal equipment.

The terminal device includes, but is not limited to, a mobile phone, a tablet computer, a wearable device, an in-vehicle device, an Augmented Reality (AR)/Virtual Reality (VR) device, a notebook computer, an ultra-mobile personal computer (UMPC), a netbook, a Personal Digital Assistant (PDA), and other terminal devices, and the specific type of the terminal device is not limited in the embodiment of the present application.

The data processing equipment comprises computing equipment which carries out data interaction through an input/output interface and processes data, wherein the computing equipment comprises but not limited to a single server, a server cluster, a distributed server, a cloud server and the like.

The remote service equipment comprises a computing device which carries out data interaction through an input/output interface and processes data, wherein the computing device comprises but not limited to a single server, a server cluster, a distributed server, a cloud server and the like.

Fig. 2 illustrates a data processing method provided by an embodiment of the present application, which is used for processing a plurality of user instructions sent by a plurality of terminal devices, and is applied to the data processing device 120 in the financial transaction system illustrated in fig. 1, and may be implemented by software/hardware of the data processing device 120. As shown in fig. 2, the method includes steps S110 to S160. The specific realization principle of each step is as follows:

s110, responding to a plurality of user instructions sent by a plurality of terminal devices, and adding the user instructions into a first data queue of a target scheduling thread according to the category of each user instruction; the target scheduling thread is a scheduling thread corresponding to the category of the user instruction in the plurality of scheduling threads.

In one non-limiting example, user instructions may be sent to the data processing device for a plurality of users, each user sending a plurality of different categories of user instructions.

In one non-limiting example, the user instruction is a financial user instruction, such as a transaction instruction, a query instruction, or the like.

In one non-limiting example, the number of scheduling threads actually run by the data processing apparatus is the number of user instruction classes.

In one non-limiting example, a data processing device receives a plurality of user instructions sent by a user through a plurality of terminal devices. The data processing device adds the user instruction to a first data queue of the target scheduling thread according to the category of the user instruction. For example, when the data processing device runs, the software system of the data processing device initiates two scheduling threads, namely a transaction processing thread and an inquiry processing thread, and the data processing device puts the transaction instruction into a transaction instruction queue of the transaction processing thread and the inquiry instruction into an inquiry instruction queue of the inquiry processing thread according to the category of the analysis user instruction. It is to be understood that, in the practical implementation of the embodiments of the present application, scheduling threads for multiple user instruction types may be executed according to practical situations, and for convenience of understanding, the present example takes a transaction processing thread and a query processing thread as examples, and is not a specific limitation of the present application.

S120, aiming at the first data queue of each target scheduling thread, adding the user instruction into a second data queue of a target coroutine according to the user identification in the user instruction in the first data queue; the target coroutine is a coroutine corresponding to the user identifier in a plurality of coroutines to be called of the target scheduling thread.

In one non-limiting example, each to-be-invoked coroutine in each dispatch thread is a program instance of a class data instruction.

In one non-limiting example, the user identification is used to uniquely identify the user, including but not limited to a user code, a user authentication certificate, and the like.

In a non-limiting example, a plurality of coroutine instances for processing the same type of user instructions are run in each scheduling thread, the coroutine number corresponds to the number of users in online transaction, each coroutine corresponds to one user in online transaction, each coroutine instance corresponds to one second data queue, and data in the second data queue is the user instructions of the corresponding user to be processed by the coroutine. In a non-limiting manner, for the first data queue of each target scheduling thread, the data processing device adds the user instruction to a second data queue of a target coroutine according to a user number in the user instruction in the first data queue; the target coroutine is a coroutine corresponding to the user number in a plurality of coroutines to be called of the target scheduling thread; the multiple coroutines to be called of the target scheduling thread correspond to the number of users of the online transaction.

And S130, respectively traversing the coroutines to be called of each target scheduling thread.

In one non-limiting example, each scheduling thread traverses the scheduling thread's co-routine to be invoked, respectively.

In a non-limiting example, the multiple coroutines to be scheduled of each target scheduling thread form a ring queue, and the coroutines to be called in the ring queue of each target scheduling thread are respectively traversed in sequence. For example, coroutines of query processing threads that have processed query instructions form a circular queue, and the query processing threads sequentially traverse the coroutines in the circular queue, which is understood to be an infinite loop process.

In a non-limiting example, the coroutines to be called of each target scheduling thread are traversed respectively, and the scheduling times are determined according to the scheduling end conditions. The scheduling end condition comprises: determining that the target scheduling thread sequentially traverses each coroutine to be called of the scheduling thread once; or determining that all the user instructions in the first data queue of the target scheduling thread are processed completely, and determining that all the user instructions in the second data queue of all the coroutines to be scheduled of the target scheduling thread are processed completely.

S140, if the currently traversed coroutine to be called meets calling-in conditions, determining the coroutine to be called as an active coroutine; and executing call-in operation on the active coroutine, and processing the user instruction in the second data queue of the active coroutine.

The call-in operation includes, but is not limited to, executing the active coroutine, and the scheduling thread of the active coroutine transfers scheduling authority to the active coroutine. The call-in operation further includes, without limitation, reading the context of the active coroutine that has been saved.

In a non-limiting example, when a scheduling thread of a data processing device traverses a coroutine to be called, a state identifier of a current coroutine is detected, and whether the currently traversed coroutine to be called meets call-in conditions is judged according to the state identifier. The state identifier includes, without limitation, an idle state and a non-idle state.

In a non-limiting example, when a scheduling thread of a data processing device traverses a protocol to be called, a state identifier of a current protocol and a second data queue of the protocol to be called are detected, and whether the currently traversed protocol to be called meets call-in conditions is judged according to whether a user instruction to be processed exists in the state identifier and the second data queue.

In a non-limiting example, if the coroutine to be called currently traversed by the scheduling thread meets the call-in condition, determining that the coroutine to be called is an active coroutine; executing call-in operation on the active coroutine, and processing user instructions in the second data queue of the active coroutine, wherein the call-in operation comprises at least one of the following modes:

if the state identifier of the currently traversed protocol to be called is in an idle state and a user instruction to be processed is in a second data queue of the protocol, determining that the protocol to be called is an active protocol, setting the first state identifier of the active protocol to be in a non-idle state, transferring the scheduling authority of the target scheduling thread to the active protocol, and taking out the user instruction in the second data queue of the active protocol to process the active protocol;

if the state identifier of the currently traversed coroutine to be called is a non-idle state, determining that the coroutine to be called is an active coroutine, executing calling operation on the active coroutine, transferring the scheduling authority of a target scheduling thread to the active coroutine, and continuously executing the active coroutine at the calling position of the active coroutine;

and if the state identifier of the currently traversed coroutine to be called is an idle state and the second data alignment of the coroutine to be called has no user instruction to be processed, determining that the call-in condition is not met.

It can be understood that the scheduling thread determines whether to call the coroutine according to the state identification of the coroutine to be called.

S150, if the active coroutine is determined to finish processing a user instruction, adding a processing result into a response queue of a response thread; and sequentially feeding back the processing results in the response team to the terminal equipment corresponding to the user identification according to the user identification of the processing results.

In one non-limiting example, when the active coroutine finishes processing a user instruction, the scheduling thread of the active coroutine adds the processing result to the response queue of the response thread. The response thread and the scheduling thread are in a parallel processing relationship, the response thread sequentially takes out processing results in a response queue, and the processing results in the response queue are sequentially fed back to the terminal equipment corresponding to the user identification according to the user identification in the processing results. It will be appreciated that the data processing device may transmit the sequence of user processing results to the user's terminal device via a wired or wireless communication network.

And S160, if the fact that the activity coroutine meets at least one of the plurality of arousing conditions is determined, carrying out arousing operation on the activity coroutine, suspending the activity coroutine, and saving the current processing position of the activity coroutine as an arousing position.

The call-out operation includes, but is not limited to, suspending execution of the active coroutine, transferring the scheduling authority of the active coroutine to the scheduling thread of the active coroutine, saving the current processing position of the active coroutine, and saving the context of the active coroutine.

In one non-limiting example, an active coroutine in a dispatch thread of a data processing apparatus performs a call-out operation on the active coroutine if at least one of a plurality of call-out conditions is satisfied during execution of a user instruction.

In one non-limiting example, the scheduling thread performs a call-out operation on the active coroutine if it is determined that the active coroutine satisfies at least one of the plurality of call-out conditions.

In one non-limiting example, the call-out condition includes: determining that the current user instruction is processed by the active coroutine, determining that a second data queue of the active coroutine is empty, and setting a state identifier of the coroutine to be an idle state; determining that the active coroutine sends a message to a remote service and needs to wait for a response message of the remote service; determining that a response message waiting for the active coroutine has not arrived; determining that the active protocol receives a waiting reply message and that the active protocol has finished processing the reply message.

It can be understood that the execution time of each user instruction in one scheduling co-program can be relatively averaged by classifying the user instructions sent by the user and processing the user instructions of the individual categories by the thread scheduling co-program corresponding to each category; furthermore, the co-program is scheduled by the scheduling thread, so that processor resources can be fully utilized, and the effect of approximate parallel processing is achieved, thereby improving the data processing efficiency.

In one non-limiting example, taking three users, user a, user B, and user C, as an example, sending user instructions to the data processing device 120, the data processing device 120 processing multiple user instructions of the three users; wherein the user instruction comprises a transaction instruction and a query instruction. As shown in fig. 3, the data processing apparatus receives an instruction sequence 311 from a user a, an instruction sequence 312 from a user B, and an instruction sequence 313 from a user C; the data processing equipment processes the user instructions and outputs a processing result sequence of each user: user A processing result sequence, user B processing result sequence and user C processing result sequence.

The instruction sequence 311 of the user a may include a query instruction of the user a or a transaction instruction of the user a, the instruction sequence 312 of the user B may include a query instruction of the user B or a transaction instruction of the user B, and the instruction sequence 311 of the user C may include a query instruction of the user C or a transaction instruction of the user C.

When the data processing apparatus 120 runs, the software system thereof initiates two scheduling threads, which are a transaction processing thread 341 and a query processing thread 342, respectively, a first data queue processed by the transaction processing thread 341 is a transaction instruction queue 331, and a first data queue processed by the query processing thread 342 is a query instruction queue 332.

After the data processing device receives the user instructions of the three users through the user interface thread 321, the data processing device puts the transaction instructions of the three users into the transaction instruction queue 331 of the transaction instruction processing thread 341 according to the types of the transaction instructions and the query instructions according to the types of the analyzed user instructions; the query instructions of the respective users are placed in the query instruction queue 332 of the query instruction processing thread 342.

The transaction processing thread 341 and the query processing thread 342 each schedule coroutines for processing user instructions, and perform parallel processing on different classes of instructions.

The transaction processing thread schedules a plurality of transaction instruction processing routines 3410 to be scheduled; the query processing thread schedules a plurality of query instruction coroutines 3420 to be scheduled, each coroutine for processing user instructions in a respective user instruction queue.

The scheduling co-process quantity of each scheduling thread corresponds to the user quantity of the online transaction.

After the coroutine in each scheduling thread processes a user instruction, the scheduling thread adds the processing result of the user instruction into the response queue 370 of the response thread 380, and feeds back the processing result of each user instruction in the response queue to each user through the response thread.

The following describes the process of scheduling each query instruction coroutine 3420 to be scheduled by the query processing thread 342 by taking the query processing thread 342 as an example. As shown in fig. 3, the dashed arrows in the query processing thread indicate that the query processing threads form a circular query processing thread queue, and the query processing thread sequentially traverses each query processing thread 3420 in the circular queue.

And if the currently traversed query instruction coroutine meets the call-in condition, determining the query instruction coroutine to be an active coroutine. And executing call-in operation on the active coroutine, and transferring the scheduling authority of the query instruction thread to the active coroutine. The activity coroutine determines data processing operation according to the state identifier of the activity coroutine, so as to process the user instruction in the user query instruction queue corresponding to the activity coroutine, for example, process the user instruction in the user A query instruction queue. If the state identifier of the query co-program to be called traversed by the current query processing thread is in an idle state and the user instruction to be processed is in the second data queue of the co-program, the query instruction co-program to be called is determined to be an active co-program, the first state identifier of the active co-program is set to be in a non-idle state, the scheduling authority of the target scheduling thread is transferred to the active co-program, and the query instruction in the second data queue of the active co-program extractor is processed. If the state identification of the query instruction coroutine to be called traversed by the query processing thread at present is a non-idle state, directly determining that the coroutine to be called is an active coroutine, executing a calling operation on the active coroutine, transferring the scheduling authority of the target scheduling thread to the active coroutine, and continuously executing the active coroutine at the calling position of the active coroutine. And if the state identifier of the currently traversed query processing thread to-be-called query instruction coroutine is an idle state and the second data alignment of the coroutine to be called has no to-be-processed user instruction, determining that the call-in condition is not met, and continuing to traverse the next query instruction coroutine by the query processing thread.

In the process of processing the user instruction by the active coroutine, the active coroutine repeatedly executes the operation of taking out the user instruction from the user execution queue of the active coroutine and processing data of the user instruction. In the process, if the active coroutine determines that the active coroutine meets at least one of a plurality of call-out conditions, executing call-out operation, suspending the active coroutine, saving the current processing position of the coroutine as a call-out position, and transferring the scheduling authority to a scheduling thread by the active coroutine.

The call-out condition comprises: determining that the current user instruction is processed by the active coroutine, determining that a second data queue of the active coroutine is empty, and setting a state identifier of the coroutine to be an idle state; determining that the activity protocol sends a message to a remote service device via a remote service interface 360 provided by the communication protocol processing thread 350 and needs to wait for a response message of the remote service; determining that a response message waiting for the active coroutine has not arrived; determining that the active protocol receives a waiting reply message and that the active protocol has finished processing the reply message.

When the embodiment of the application is implemented, the processing performance of the enquiry instruction of the exchange is compared and tested, and the test result is shown in table 1.

TABLE 1

It will be appreciated that upon being called out at an appropriate location, the scheduling thread may take full advantage of the scheduled coroutines that may wait for a reply message opportunity. The scheduling thread is used for scheduling the coroutine to process a class of user instructions, so that the processor is fully and effectively executed for processing the coroutine, possible invalid waiting corresponding to the calling-out condition is avoided, and the effect of approximate parallelism processing is achieved; in one practical system, the latency of remote calls across the internet is at least on the order of milliseconds. If the mode is used, one thread can schedule and drive dozens to hundreds of coroutine objects to carry out concurrent calling, and each single coroutine is scheduled to occupy few thread resources, so that the invalid waiting condition of the processor is greatly reduced, and the effect of approaching to concurrent processing is achieved. The system utilization rate is improved, and the software parallel processing architecture and the communication architecture of the existing financial system do not need to be modified in a large scale, so that the cost is saved.

It is understood that the above example takes the data processing device processing a plurality of transaction instructions and query instructions of three users as an example to better illustrate the technical solution of the present application, and those skilled in the art can determine the number of processing users and the number of types of instructions according to actual situations when implementing the implementation of the present application. This example is not a specific limitation of the present application.

It should be understood that, the sequence numbers of the steps in the foregoing embodiments do not imply an execution sequence, and the execution sequence of each process should be determined by its function and inherent logic, and should not constitute any limitation to the implementation process of the embodiments of the present application.

Corresponding to the above method for data processing shown in fig. 2, fig. 4 shows a data processing apparatus provided in an embodiment of the present application, including:

a first data allocation module M110, configured to respond to a plurality of user instructions sent by a plurality of terminal devices, and add the user instructions into a first data queue of a target scheduling thread according to the category of each user instruction; the target scheduling thread is a scheduling thread corresponding to the category of the user instruction in a plurality of scheduling threads;

a second data allocation module M120, configured to add, according to a user identifier in a user instruction in the first data queue, the user instruction to a second data queue of a target coroutine for the first data queue of each target scheduling thread; the target coroutine is a coroutine corresponding to the user identifier in a plurality of coroutines to be called of the target scheduling thread;

a traversing module M130, configured to respectively traverse the coroutines to be called of each target scheduling thread;

the call-in module M140 is configured to determine that the coroutine to be called is an active coroutine if the currently traversed coroutine to be called meets a call-in condition; executing call-in operation on the active coroutine, and processing a user instruction in the second data queue of the active coroutine;

an output module M150, configured to add a processing result to a response queue of a response thread if it is determined that the active coroutine has finished processing a user instruction; according to the user identification of the processing result, sequentially feeding back the processing result in the response team to the terminal equipment corresponding to the user identification;

and the call-out module M160 is used for executing call-out operation on the active coroutine if the active coroutine is determined to meet at least one of a plurality of call-out conditions, suspending the active coroutine, and saving the current processing position of the coroutine as a call-out position.

It is understood that various embodiments and combinations of the embodiments in the above embodiments and their advantages are also applicable to this embodiment, and are not described herein again.

Fig. 5 is a schematic structural diagram of a data processing device according to an embodiment of the present application. As shown in fig. 5, the data processing device D5 of this embodiment includes: at least one processor D50 (only one of which is shown in fig. 5), a memory D51, and a computer program D52 stored in the memory D51 and executable on the at least one processor D50, the processor D50, when executing the computer program D52, implementing the steps in any of the various method embodiments described above. Alternatively, the processor D50 realizes the functions of the modules/units in the above-mentioned device embodiments when executing the computer program D52.

The data processing device D5 may be a desktop computer, a notebook computer, a palm top computer, a cloud server, or other computing devices. The data processing device may include, but is not limited to, a processor D50, a memory D51. Those skilled in the art will appreciate that fig. 5 is merely an example of a data processing device D5 and is not intended to be limiting of data processing device D5, and may include more or fewer components than those shown, or some components in combination, or different components, such as input output devices, network access devices, etc.

The Processor D50 may be a Central Processing Unit (CPU), the Processor D50 may be other general purpose processors, Digital Signal Processors (DSP), Application Specific Integrated Circuits (ASIC), Field-Programmable Gate arrays (FPGA) or other Programmable logic devices, discrete Gate or transistor logic devices, discrete hardware components, etc. A general purpose processor may be a microprocessor or the processor may be any conventional processor or the like.

The storage D51 may be, in some embodiments, an internal storage unit of the data processing device D5, such as a hard disk or memory of the data processing device D5. The memory D51 may also be an external storage device of the data processing device D5 in other embodiments, such as a plug-in hard disk, a Smart Media Card (SMC), a Secure Digital (SD) Card, a Flash memory Card (Flash Card), etc., provided on the data processing device D5. Further, the memory D51 may also include both internal storage units and external storage devices of the data processing device D5. The memory D51 is used for storing an operating system, application programs, a BootLoader (BootLoader), data, and other programs, such as program codes of the computer programs. The memory D51 may also be used to temporarily store data that has been output or is to be output.

It should be noted that, for the information interaction, execution process, and other contents between the above-mentioned devices/units, the specific functions and technical effects thereof are based on the same concept as those of the embodiment of the method of the present application, and specific reference may be made to the part of the embodiment of the method, which is not described herein again.

It will be apparent to those skilled in the art that, for convenience and brevity of description, only the above-mentioned division of the functional units and modules is illustrated, and in practical applications, the above-mentioned function distribution may be performed by different functional units and modules according to needs, that is, the internal structure of the apparatus is divided into different functional units or modules to perform all or part of the above-mentioned functions. Each functional unit and module in the embodiments may be integrated in one processing unit, or each unit may exist alone physically, or two or more units are integrated in one unit, and the integrated unit may be implemented in a form of hardware, or in a form of software functional unit. In addition, specific names of the functional units and modules are only for convenience of distinguishing from each other, and are not used for limiting the protection scope of the present application. The specific working processes of the units and modules in the system may refer to the corresponding processes in the foregoing method embodiments, and are not described herein again.

The embodiments of the present application further provide a computer-readable storage medium, where a computer program is stored, and when the computer program is executed by a processor, the computer program implements the steps in the above-mentioned method embodiments.

Embodiments of the present application provide a computer program product, which when executed on a data processing device, enables the data processing device to implement the steps in the above method embodiments.

The integrated unit, if implemented in the form of a software functional unit and sold or used as a stand-alone product, may be stored in a computer readable storage medium. Based on such understanding, all or part of the processes in the methods of the embodiments described above can be implemented by a computer program, which can be stored in a computer-readable storage medium and can implement the steps of the embodiments of the methods described above when the computer program is executed by a processor. Wherein the computer program comprises computer program code, which may be in the form of source code, object code, an executable file or some intermediate form, etc. The computer readable medium may include at least: any entity or device capable of carrying computer program code to a photographing apparatus/terminal apparatus, a recording medium, computer Memory, Read-Only Memory (ROM), Random Access Memory (RAM), electrical carrier wave signal, telecommunication signal, and software distribution medium. Such as a usb-disk, a removable hard disk, a magnetic or optical disk, etc. In certain jurisdictions, computer-readable media may not be an electrical carrier signal or a telecommunications signal in accordance with legislative and patent practice.

In the above embodiments, the descriptions of the respective embodiments have respective emphasis, and reference may be made to the related descriptions of other embodiments for parts that are not described or illustrated in a certain embodiment.

Those of ordinary skill in the art will appreciate that the various illustrative elements and algorithm steps described in connection with the embodiments disclosed herein may be implemented as electronic hardware or combinations of computer software and electronic hardware. Whether such functionality is implemented as hardware or software depends upon the particular application and design constraints imposed on the implementation. Skilled artisans may implement the described functionality in varying ways for each particular application, but such implementation decisions should not be interpreted as causing a departure from the scope of the present application.

In the embodiments provided in the present application, it should be understood that the disclosed apparatus/network device and method may be implemented in other ways. For example, the above-described apparatus/network device embodiments are merely illustrative, and for example, the division of the modules or units is only one logical division, and there may be other divisions when actually implementing, for example, a plurality of units or components may be combined or integrated into another system, or some features may be omitted, or not implemented. In addition, the shown or discussed mutual coupling or direct coupling or communication connection may be an indirect coupling or communication connection through some interfaces, devices or units, and may be in an electrical, mechanical or other form.

The units described as separate parts may or may not be physically separate, and parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on a plurality of network units. Some or all of the units can be selected according to actual needs to achieve the purpose of the solution of the embodiment.

The above-mentioned embodiments are only used for illustrating the technical solutions of the present application, and not for limiting the same; although the present application has been described in detail with reference to the foregoing embodiments, it should be understood by those of ordinary skill in the art that: the technical solutions described in the foregoing embodiments may still be modified, or some technical features may be equivalently replaced; such modifications and substitutions do not substantially depart from the spirit and scope of the embodiments of the present application and are intended to be included within the scope of the present application.

Claims

1. A method of data processing, comprising:

and if the active coroutine is determined to meet at least one of the plurality of call-out conditions, executing a call-out operation on the active coroutine, suspending the active coroutine, and saving the current processing position of the active coroutine as a call-out position.

2. The method of claim 1, wherein if the currently traversed coroutine to be called meets call-in conditions, determining that the coroutine to be called is an active coroutine; executing call-in operation on the active coroutine, and processing user instructions in the second data queue of the active coroutine, wherein the call-in operation comprises at least one of the following modes:

if the state identifier of the currently traversed protocol to be called is in an idle state and a user instruction to be processed is in a second data queue of the protocol, determining that the protocol to be called is an active protocol, setting the first state identifier of the active protocol to be in a non-idle state, and taking out the user instruction in the second data queue of the active protocol to process the active protocol;

if the state identifier of the currently traversed coroutine to be called is a non-idle state, determining that the coroutine to be called is an active coroutine, executing calling operation on the active coroutine, and continuously executing the active coroutine at the calling position of the active coroutine;

3. The method of claim 1, wherein the call condition comprises:

determining that the current user instruction is processed by the active coroutine, determining that a second data queue of the active coroutine is empty, and setting a state identifier of the coroutine to be an idle state;

determining that the active coroutine sends a message to a remote service and needs to wait for a response message of the remote service;

determining that a response message waiting for the active coroutine has not arrived;

determining that the active protocol receives a waiting reply message and that the active protocol has finished processing the reply message.

4. The method of claim 1, wherein traversing the to-be-invoked coroutines of each of the target dispatch threads separately comprises:

and respectively traversing the coroutines to be called of each target scheduling thread, and determining the scheduling times according to the scheduling ending conditions.

5. The method of claim 4, the schedule end condition comprising:

determining that the target scheduling thread sequentially traverses each coroutine to be called of the scheduling thread once; or the like, or, alternatively,

and determining that all the user instructions in the first data queue of the target scheduling thread are processed completely, and determining that all the user instructions in the second data queue of all the coroutines to be scheduled of the target scheduling thread are processed completely.

6. The method of claim 1, wherein traversing the to-be-invoked coroutines of each of the target dispatch threads separately comprises:

and forming a ring queue by the multiple coroutines to be scheduled of each target scheduling thread, and respectively traversing the coroutines to be called in the ring queue of each target scheduling thread in sequence.

7. The method of claim 1, wherein for the first data queue of each of the target dispatch threads, the user instruction is added to a second data queue of a target coroutine based on a user identification in the user instruction in the first data queue; the target coroutine is a coroutine corresponding to the user identifier in a plurality of coroutines to be called of the target scheduling thread, and comprises the following steps:

adding the user instruction into a second data queue of the target coroutine according to the user number in the user instruction in the first data queue aiming at the first data queue of each target scheduling thread; the target coroutine is a coroutine corresponding to the user number in a plurality of coroutines to be called of the target scheduling thread; the multiple coroutines to be called of the target scheduling thread correspond to the number of users of the online transaction.

8. An apparatus for data processing, comprising:

9. A data processing apparatus comprising a memory, a processor and a computer program stored in the memory and executable on the processor, characterized in that the processor implements the method according to any of claims 1 to 7 when executing the computer program.

10. A computer-readable storage medium, in which a computer program is stored which, when being executed by a processor, carries out the method according to any one of claims 1 to 7.