CN113032118A - Asynchronous operation processing method for computer application program and corresponding system - Google Patents
Asynchronous operation processing method for computer application program and corresponding system Download PDFInfo
- Publication number
- CN113032118A CN113032118A CN202110302954.8A CN202110302954A CN113032118A CN 113032118 A CN113032118 A CN 113032118A CN 202110302954 A CN202110302954 A CN 202110302954A CN 113032118 A CN113032118 A CN 113032118A
- Authority
- CN
- China
- Prior art keywords
- task
- calling
- instance
- asynchronous operation
- executor
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/48—Program initiating; Program switching, e.g. by interrupt
- G06F9/4806—Task transfer initiation or dispatching
- G06F9/4843—Task transfer initiation or dispatching by program, e.g. task dispatcher, supervisor, operating system
- G06F9/4881—Scheduling strategies for dispatcher, e.g. round robin, multi-level priority queues
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Debugging And Monitoring (AREA)
Abstract
Asynchronous operation processing methods for computer applications and corresponding systems, computer devices, and media are provided. The method comprises the following steps: generating a task processing instance in a computer application program, wherein the task processing instance comprises an executor and a task queue; binding a self-instance of at least one module or component with a task processing instance such that calls to the at least one module or component are hosted by the task processing instance; receiving a call instruction to the hosted at least one module or component via the computer application, generating a corresponding call task in response to the call instruction and adding the generated call task to a task queue of the task processing instance; and the executor of the task processing instance executes the calling tasks in the task queue according to the calling sequence. The invention is beneficial to eliminating the uncertainty of the sequencing of the results of asynchronous operation triggered when a plurality of components are called for multiple times, and ensures the stable state or behavior of the front-end component of the computer application program.
Description
Technical Field
The present invention relates to the field of computer applications, and more particularly, to an asynchronous operation processing method for a computer application, a corresponding system, a computer device, and a computer-readable storage medium.
Background
Currently, the front-end technology of computer software applications is increasingly complex. The front-end function page of a large application typically includes a plurality of modules, each of which typically includes a plurality of components, and the implementation of a function typically involves inter-calling between the components and asynchronous operation (e.g., data interaction, etc.) with a back-end server. Therefore, the call logic of the front-end function page of the application is very complicated.
Because 1) asynchronous operation is related to network status; and 2) due to the fact that the back end is subjected to micro-service, the response time of different servers is different, and the like, the situation of 'calling later and responding first' often occurs, and the state or behavior of the front end component when the front end component meets the problems is often incorrect, so that the user cannot normally use the application program. In addition, the existing state management mechanism heavily depends on a bottom development framework, and cannot achieve cross-platform and framework support.
Accordingly, there is a need for an improved asynchronous operation processing scheme for computer applications.
Disclosure of Invention
It is an object of the present invention to provide a solution that solves or alleviates at least one of the above problems.
Specifically, according to a first aspect of the present invention, there is provided an asynchronous operation processing method for a computer application, comprising:
generating a task processing instance within the computer application, the task processing instance comprising an executor and a task queue;
binding a self-instance of at least one module or component with the task processing instance such that calls to the at least one module or component are hosted by the task processing instance;
receiving, via the computer application, a call instruction to at least one module or component hosted, in response to the call instruction, generating a corresponding call task and adding the generated call task to the task queue of the task processing instance; and
and the executor of the task processing instance executes the calling tasks in the task queue according to a calling sequence.
According to a second aspect of the present invention there is provided an asynchronous operation processing system for a computer application comprising a processor configured to execute computer instructions to:
generating a task processing instance within the computer application, the task processing instance comprising an executor and a task queue;
binding a self-instance of at least one module or component with the task processing instance such that calls to the at least one module or component are hosted by the task processing instance;
receiving, via the computer application, a call instruction to at least one module or component hosted, in response to the call instruction, generating a corresponding call task and adding the generated call task to the task queue of the task processing instance; and
and enabling the executor of the task processing instance to execute the calling tasks in the task queue according to a calling sequence.
According to a third aspect of the present invention, there is provided a computer device comprising a memory and a processor, the memory having stored thereon computer instructions which, when executed by the processor, cause the above-described asynchronous operation processing method to be performed.
According to a fourth aspect of the present invention, there is provided a non-transitory computer readable storage medium having stored thereon computer instructions which, when executed by a processor, cause the above-described asynchronous operation processing method to be performed.
By the scheme of the invention, the task processing instance can be generated to host the call to at least one module or component, so that the call to the component and the asynchronous operation involved in the component can be ordered and controlled. Therefore, the method helps to furthest eliminate the uncertainty of the sequence of the results of asynchronous operation triggered when multiple calls of a plurality of components are carried out, ensures the state or behavior of the front-end component of the computer application program to be stable, does not depend on a bottom development framework, and can realize cross-platform and framework support.
Drawings
Non-limiting and non-exhaustive embodiments of the present invention are described by way of example with reference to the following drawings, in which:
FIG. 1 is a flow diagram that schematically illustrates a method for asynchronous operation processing of a computer application, in accordance with an embodiment of the present invention;
FIG. 2 is a diagram that schematically illustrates the processing of asynchronous operations by a task processing instance, in accordance with an embodiment of the present invention.
Detailed Description
In order to make the above and other features and advantages of the present invention more apparent, the present invention is further described below with reference to the accompanying drawings. It is understood that the specific embodiments described herein are for purposes of illustration only and are not intended to be limiting.
In general, aspects of the present invention are applicable to a variety of situations in which asynchronous operations within a computer application are handled in the computer application in response to a user's associated operations. Such as, but not limited to, asynchronous operations involved in the modules, or asynchronous operations involved in the components, etc., due to user operations on the computer application. Including, for example and without limitation, browser applications, financial software, office software, and the like.
The computer application may be an application implemented using various programming languages, and the front-end function page may be a front-end function page implemented using various programming languages. The computer application may be software installed on the user terminal device, a computer application for inputting a website opened using a browser, or the like. Examples of the user terminal device may include, for example, but not limited to, a desktop computer, a laptop computer, a personal digital assistant, or a cell phone, etc. The data source of the data with which the user interacts may be a local data source, or an accessible remote data source, depending on the particular situation. The local data source may be located in a memory of the user terminal device. Remote data sources include data sources that are not local to the user terminal device and that the user terminal device can access through various communication means, such as a mobile network (4G or 5G) or Wi-Fi, etc.
FIG. 1 schematically illustrates an asynchronous operation processing method 100 for a computer application according to an embodiment of the present invention. The method 100 may include step S110, step S120, step S130, and step S140.
At step S110, a task processing instance is generated within the computer application, the task processing instance including an executor and a task queue (alternatively referred to as a "wait queue"). For example, where asynchronous operations are involved within a module of the computer application, a task processing instance is generated within the module; in the case where asynchronous operations are involved within a component of the computer application, a task processing instance is generated within the component. The task processing instance can be generated by using the same implementation language as the computer application program, and the generation method is used for generating a new instance statement for the implementation language. For example, when the implementation language of the computer application is JavaScript, a task processing instance may be generated using a statement var task queue () where task queue is an object (i.e., an instance) that can call a method, and task queue is a constructor provided by the asynchronous operation processing method described herein. Specifically, the task processing instance may refer to an object that is finally generated for calling by referring to the asynchronous operation processing method in the present document, and may be, for example, a constructor or a code segment provided to a caller.
At step S120, a self-instance of at least one module or component in the computer application is bound to the task processing instance such that a call to the at least one module or component is hosted by the task processing instance. For example, where asynchronous operations are involved within a module of the computer application, binding self-instances of a plurality of components within the module with the task processing instance; in the event that asynchronous operations are involved within a component of the computer application, binding a self-instance within the component with the task processing instance. After binding, calls to the at least one module or component are hosted by the task processing instance, which controls the calls to the at least one module or component. "binding" means that a party that needs to invoke (e.g., a module/component with similar requirements) saves a task processing instance for invocation when needed.
At step S130, a call instruction to the hosted at least one module or component is received via the computer application, in response to the call instruction, a corresponding call task is generated and the generated call task is added to the task queue of the task processing instance. The call instruction is due to a user's operation of the computer application, which will accordingly call the component to have performed the function desired by the user. The invocation tasks are generated in response to the invocation instructions invoking methods within the modules or components, and may correspond to multiple invocations of the same method of the same component or invocations of different methods of different components. The invocation tasks may be generated simultaneously or within substantially the same time (e.g., within no more than tens of seconds of each other).
In step S140, the executor of the task processing instance executes the calling tasks in the task queue according to a calling order.
In an embodiment, when the calling task is added into the task queue, the caller obtains an asynchronous operation processing function in an uncompleted state; and/or after the calling task is executed and completed by the executor, the calling party obtains the asynchronous operation processing function in the successful state, and the executor provides the running result of the executed calling task to the asynchronous operation processing function after the corresponding calling task is executed and completed.
For example, the asynchronous operation handling function may be a promise instance, which is a container in which the result of a future event (e.g., an asynchronous operation) is stored, and which has three states: pending, filled and rejected states, the state of the asynchronous operation may be obtained from the commit instance. The state of the promise instance is associated with the progress state of the asynchronous operation, and whether the asynchronous operation is performed and completed can be known by monitoring the state of the promise instance. When there are multiple tasks in the task queue, there is a commit instance in each task, and the state of each task can be reflected using the commit instance.
In an embodiment, when the calling tasks in the task queue access the same resource or the accessed resources thereof are intersected with each other, the executor executes all the calling tasks added into the task queue one by one according to the calling sequence, and the running result of each of the calling tasks can be provided to the asynchronous operation processing function to be returned to a caller.
For example, task 1 is a +1, and task2 is a +2, and these two tasks access the same data a stored in the database, assuming that the initial value of a originally stored in the database is 1. The executor executes a +1 according to a calling sequence, provides an operation result 2 of the a +1 to the asynchronous operation processing function and returns the operation result to a calling party, and the calling party obtains a result 2; and the executor executes a +2 again according to the calling sequence, provides the running result 4 of the a +2 to the asynchronous operation processing function and returns the running result to the caller, and the caller obtains the result 4.
In another embodiment, when the resources accessed by the calling tasks in the task queue are relatively independent, all the calling tasks added into the task queue are grouped according to a calling method or a predefined configuration, the executor executes the calling tasks according to the groups and according to the calling sequence in the groups, and the result of the last executed calling task in each group is provided to the asynchronous operation processing function to be returned to a calling party.
For example, task 1 is a +1, task2 is a +2, and task 3 is b +1, and these three tasks access data a or b stored in the database, assuming that the initial value of a originally stored in the database is 1 and the initial value of b is 0. Since both task 1 and task2 involve variable a, task 1 and task2 are grouped together and task 3 is grouped together. The executor executes the tasks a +1 and a +2 according to the group, each task in the group is executed, but the operation result 2 of a +1 is not provided to the asynchronous operation processing function as the execution result of the task 1 and is returned to the caller, and after the execution of all tasks (i.e., the task 2) in the group is finished, the final result 4 is used as the final execution result common to the tasks 1 and 2, the execution result of the task 1 and the execution result of the task2 are both 4, and the caller obtains the result 4; and the executor executes the task b +1 according to the grouping, provides the running result 1 of the b +1 to the asynchronous operation processing function and returns the running result to the caller, and the caller obtains the result 1. Compared with the execution strategy according to the calling order, the execution strategy in a grouping mode has better execution efficiency, but the application scene is limited.
In another embodiment, when the calling task is executed in the executor, the task processing instance is in a busy state; and when all the calling tasks in the task queue are executed, the task processing instance releases the busy state.
The default state of a task processing instance herein is no longest latency, i.e., infinite long latency. However, the user can set a time length according to the self requirement, and the time length has no additional limitation. For example, the task processing instance may be set for a threshold time (alternatively referred to as a "maximum wait time") to control the execution of a single calling task not to exceed the threshold time, if the threshold time is exceeded, the current calling task may be discarded and the caller may get the asynchronous operation processing function in a rejected state.
For example, the longest wait time may be used as a parameter of the method called when adding a task to the task queue, such as maxWaitingTime in the example of task.
In yet another embodiment, based on the busy state of the task processing instance, the caller can perform an operation based on the busy state, wherein the operation includes giving up reading a variable related to a corresponding calling task in the task processing instance when the caller finds that the task processing instance is in the busy state, because the current value of the variable is not the latest value.
FIG. 2 schematically illustrates a process for a task processing instance to handle asynchronous operations, according to an embodiment of the invention.
As shown in FIG. 2, a task processing instance is generated within a computer application, the task processing instance including an executor and a task queue; binding a self-instance of at least one module or component with the task processing instance such that calls to the at least one module or component are hosted by the task processing instance; receiving, via the computer application, a call instruction to at least one module or component hosted, in response to the call instruction, generating a corresponding call task and adding the generated call task to the task queue of the task processing instance; and the executor of the task processing instance executes the calling tasks in the task queue according to a calling sequence.
In fig. 2, 4 call tasks Task 0, Task 1, Task2, and Task 3 are generated in response to a call instruction, Task 0 is being executed in an executor, and Task 1, Task2, and Task 3 are added to the Task queue of the Task processing instance. As shown in FIG. 2, after the executor has executed Task 0, it will provide the real run result, and will continue to execute Task 1 in the order called. In addition to Task 0, Task 1, Task2, and Task 3, parameters and contexts (e.g., related data) needed for execution are added to the Task queue. Each calling task contains a commit instance to save and reflect the results of the asynchronous operation. In addition, the state monitoring can be carried out on a plurality of calling tasks and executors.
The present invention may be implemented as an asynchronous operation processing system for a computer application, the system comprising a processor configured to execute computer instructions to perform some or all of the steps of the asynchronous operation processing method described herein above.
In particular, the processor may be configured to execute computer instructions to:
generating a task processing instance within the computer application, the task processing instance comprising an executor and a task queue;
binding a self-instance of at least one module or component in the computer application with the task processing instance such that calls to the at least one module or component are hosted by the task processing instance;
receiving, via the computer application, a call instruction to at least one module or component hosted, in response to the call instruction, generating a corresponding call task and adding the generated call task to the task queue of the task processing instance; and
and enabling the executor of the task processing instance to execute the calling tasks in the task queue according to a calling sequence.
In one embodiment, the processor is further configured to execute the computer instructions to:
when the calling task is added into the task queue, a calling party obtains an asynchronous operation processing function in an uncompleted state; and/or
After the calling task is executed and completed by the executor, the caller obtains the asynchronous operation processing function in the successful state, and the executor provides the running result of the executed calling task to the asynchronous operation processing function after the corresponding calling task is executed and completed.
In another embodiment, the processor is further configured to execute the computer instructions to:
when the calling tasks in the task queue access the same resource or the accessed resources are intersected with each other, the executor is enabled to execute all the calling tasks added into the task queue one by one according to the calling sequence, and the running result of each calling task can be provided for the asynchronous operation processing function to be returned to a calling party.
According to yet another aspect of the present invention, there is provided a computer device comprising a memory and a processor, the memory having stored thereon computer instructions executable by the processor, the computer instructions, when executed by the processor, instructing the processor to perform the steps of the asynchronous operation processing method for computer applications of the present invention. The computer device may broadly be a server, a terminal, or any other electronic device having the necessary computing and/or processing capabilities. In one embodiment, the computer device may include a processor, memory, a network interface, a communication interface, etc., connected by a system bus. The processor of the computer device may be used to provide the necessary computing, processing and/or control capabilities. The memory of the computer device may include non-volatile storage media and internal memory. An operating system, a computer program, and the like may be stored in or on the non-volatile storage medium. The internal memory may provide an environment for the operating system and the computer programs in the non-volatile storage medium to run. The network interface and the communication interface of the computer device may be used to connect and communicate with an external device through a network. The computer program, when executed by a processor, performs the steps of the asynchronous operation processing method of the present invention for a computer application.
According to yet another aspect of the present invention, there is also provided a computer readable storage medium having stored thereon a computer program which, when executed by a processor, causes the steps of the asynchronous operation processing method described herein above to be performed. In one embodiment, the computer program is distributed across a plurality of computer devices or processors coupled by a network such that the computer program is stored, accessed, and executed by one or more computer devices or processors in a distributed fashion. A single method step/operation, or two or more method steps/operations, may be performed by a single computer device or processor or by two or more computer devices or processors. One or more method steps/operations may be performed by one or more computer devices or processors, and one or more other method steps/operations may be performed by one or more other computer devices or processors. One or more computer devices or processors may perform a single method step/operation, or perform two or more method steps/operations.
It will be understood by those skilled in the art that all or part of the steps of the asynchronous operation processing method for a computer application program of the present invention may be directed to relevant hardware, such as a computer device or a processor, by a computer program, which may be stored in a non-transitory computer readable storage medium, and which when executed causes the steps of the asynchronous operation processing method for a computer application program of the present invention to be performed. Any reference herein to memory, storage, databases, or other media may include non-volatile and/or volatile memory, as appropriate. Examples of non-volatile memory include read-only memory (ROM), programmable ROM (prom), electrically programmable ROM (eprom), electrically erasable programmable ROM (eeprom), flash memory, magnetic tape, floppy disk, magneto-optical data storage device, hard disk, solid state disk, and the like. Examples of volatile memory include Random Access Memory (RAM), external cache memory, and the like.
The respective technical features described above may be arbitrarily combined. Although not all possible combinations of features are described, any combination of features should be considered to be covered by the present specification as long as there is no contradiction between such combinations.
While the present invention has been described in connection with the embodiments, it is to be understood by those skilled in the art that the foregoing description and drawings are merely illustrative and not restrictive of the broad invention, and that this invention not be limited to the disclosed embodiments. Various modifications and variations are possible without departing from the spirit of the invention.
Claims (12)
1. A method for asynchronous operation processing of a computer application, comprising:
generating a task processing instance within the computer application, the task processing instance comprising an executor and a task queue;
binding a self-instance of at least one module or component in the computer application with the task processing instance such that calls to the at least one module or component are hosted by the task processing instance;
receiving, via the computer application, a call instruction to at least one module or component hosted, in response to the call instruction, generating a corresponding call task and adding the generated call task to the task queue of the task processing instance; and
and the executor of the task processing instance executes the calling tasks in the task queue according to a calling sequence.
2. The method of claim 1, wherein the method further comprises:
when the calling task is added into the task queue, the calling party obtains an asynchronous operation processing function in an uncompleted state; and/or
After the calling task is executed by the executor, the caller obtains the asynchronous operation processing function in the successful state, and the executor provides the running result of the executed calling task to the asynchronous operation processing function after the corresponding calling task is executed.
3. The method of claim 1, wherein the method further comprises:
when the calling tasks in the task queue access the same resource or the accessed resources are intersected with each other, the executor executes all the calling tasks added into the task queue one by one according to the calling sequence, and the running result of each calling task can be provided for the asynchronous operation processing function to be returned to a calling party.
4. The method of claim 1, wherein the method further comprises:
when the resources accessed by the calling tasks in the task queue are relatively independent, grouping all the calling tasks added into the task queue according to a calling method or a predefined configuration, executing the calling tasks according to the grouping and according to the calling sequence in the grouping by the executor, and providing the result of the last executed calling task in each grouping to the asynchronous operation processing function to return to a caller.
5. The method of claim 1, wherein,
when the calling task is executed in the executor, the task processing instance is in a busy state; and/or
And when all the calling tasks in the task queue are executed, the task processing instance releases the busy state.
6. The method of claim 1, wherein the task processing instance is set for a threshold time to control execution of a single calling task not to exceed the threshold time, and if the threshold time is exceeded, the current calling task is discarded and the caller will get the asynchronous operation processing function in a rejected state.
7. The method of claim 5, wherein the method further comprises based on a busy state of the task processing instance, a caller being able to perform an operation based on the busy state, wherein the operation comprises forgoing reading variables involved in a respective calling task in the task processing instance.
8. An asynchronous operation processing system for a computer application comprising a processor, wherein the processor is configured to execute computer instructions to:
generating a task processing instance within the computer application, the task processing instance comprising an executor and a task queue;
binding a self-instance of at least one module or component in the computer application with the task processing instance such that calls to the at least one module or component are hosted by the task processing instance;
receiving, via the computer application, a call instruction to at least one module or component hosted, in response to the call instruction, generating a corresponding call task and adding the generated call task to the task queue of the task processing instance; and
and enabling the executor of the task processing instance to execute the calling tasks in the task queue according to a calling sequence.
9. The system of claim 8, wherein the processor is further configured to execute computer instructions to:
when the calling task is added into the task queue, a calling party obtains an asynchronous operation processing function in an uncompleted state; and/or
After the calling task is executed and completed by the executor, the caller obtains the asynchronous operation processing function in the successful state, and the executor provides the running result of the executed calling task to the asynchronous operation processing function after the corresponding calling task is executed and completed.
10. The system of claim 8, wherein the processor is further configured to execute computer instructions to:
when the calling tasks in the task queue access the same resource or the accessed resources are intersected with each other, the executor is enabled to execute all the calling tasks added into the task queue one by one according to the calling sequence, and the running result of each calling task can be provided for the asynchronous operation processing function to be returned to a calling party.
11. A computer device comprising a memory and a processor, characterized in that the memory has stored thereon computer instructions which, when executed by the processor, cause the asynchronous operation processing method according to any of claims 1 to 7 to be performed.
12. A non-transitory computer-readable storage medium having stored thereon computer instructions, wherein the computer instructions, when executed by a processor, cause the asynchronous operation processing method according to any one of claims 1 to 7 to be performed.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110302954.8A CN113032118A (en) | 2021-03-22 | 2021-03-22 | Asynchronous operation processing method for computer application program and corresponding system |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110302954.8A CN113032118A (en) | 2021-03-22 | 2021-03-22 | Asynchronous operation processing method for computer application program and corresponding system |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN113032118A true CN113032118A (en) | 2021-06-25 |
Family
ID=76472235
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202110302954.8A Pending CN113032118A (en) | 2021-03-22 | 2021-03-22 | Asynchronous operation processing method for computer application program and corresponding system |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN113032118A (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114501057A (en) * | 2021-12-17 | 2022-05-13 | 阿里巴巴（中国）有限公司 | Data processing method, storage medium, processor and system |
Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109358956A (en) * | 2018-09-30 | 2019-02-19 | 上海保险交易所股份有限公司 | Service calling method |
| CN109542642A (en) * | 2018-11-15 | 2019-03-29 | 网宿科技股份有限公司 | A kind of method and device of front-end task processing |
| US20190129747A1 (en) * | 2017-10-30 | 2019-05-02 | EMC IP Holding Company LLC | Elastic Scaling Job Thread Pool in a Cloud Event Process Infrastructure |
| CN112114955A (en) * | 2020-09-28 | 2020-12-22 | 广州锦行网络科技有限公司 | Method for realizing single-process single-thread completion port under Windows platform |
| CN112181661A (en) * | 2020-10-13 | 2021-01-05 | 极道科技（北京）有限公司 | Task scheduling method |
-
2021
- 2021-03-22 CN CN202110302954.8A patent/CN113032118A/en active Pending
Patent Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20190129747A1 (en) * | 2017-10-30 | 2019-05-02 | EMC IP Holding Company LLC | Elastic Scaling Job Thread Pool in a Cloud Event Process Infrastructure |
| CN109358956A (en) * | 2018-09-30 | 2019-02-19 | 上海保险交易所股份有限公司 | Service calling method |
| CN109542642A (en) * | 2018-11-15 | 2019-03-29 | 网宿科技股份有限公司 | A kind of method and device of front-end task processing |
| CN112114955A (en) * | 2020-09-28 | 2020-12-22 | 广州锦行网络科技有限公司 | Method for realizing single-process single-thread completion port under Windows platform |
| CN112181661A (en) * | 2020-10-13 | 2021-01-05 | 极道科技（北京）有限公司 | Task scheduling method |
Non-Patent Citations (1)
| Title |
|---|
| 刘键: "《分布式计算机系统》", 30 April 1990, 人民邮电出版社 * |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114501057A (en) * | 2021-12-17 | 2022-05-13 | 阿里巴巴（中国）有限公司 | Data processing method, storage medium, processor and system |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN106998343B (en) | Remote procedure call processing method, device and system | |
| CN110162344B (en) | Isolation current limiting method and device, computer equipment and readable storage medium | |
| CN112035110B (en) | Parameter adjusting method, device, client and storage medium | |
| CN109873863B (en) | Asynchronous calling method and device of service | |
| US9880860B2 (en) | Automatic return to synchronization context for asynchronous computations | |
| CN114281263A (en) | Storage resource processing method, system and equipment of container cluster management system | |
| US10803413B1 (en) | Workflow service with translator | |
| CN109614271B (en) | Method, device, equipment and storage medium for controlling consistency of multiple cluster data | |
| US20180203743A1 (en) | Maintaining the responsiveness of a user interface while performing a synchronous operation | |
| CN113032118A (en) | Asynchronous operation processing method for computer application program and corresponding system | |
| US20210224055A1 (en) | Data interface processing method, device, server and medium | |
| CN113191889A (en) | Wind control configuration method, configuration system, electronic device and readable storage medium | |
| KR20210040322A (en) | Scheduling method and apparatus, device and storage medium | |
| CN111294377B (en) | Dependency network request sending method, terminal device and storage medium | |
| CN116541167A (en) | System flow control method, device, electronic equipment and computer readable medium | |
| CN112948118B (en) | Edge computing method, platform, computer device and readable storage medium | |
| CN113760487B (en) | Service processing method and device | |
| CN113779122B (en) | Method and device for exporting data | |
| CN107632893B (en) | Message queue processing method and device | |
| CN112882774A (en) | Intelligent contract chip device and method executed in parallel and block chain link point device | |
| CN109547563B (en) | Message push processing method and device, storage medium and server | |
| CN114116150A (en) | Task scheduling method and device and related equipment | |
| CN112650502A (en) | Batch processing task processing method and device, computer equipment and storage medium | |
| US9800692B2 (en) | Expression based declarative data service execution chaining | |
| CN112766768B (en) | Contract flow management method and device, electronic equipment and readable storage medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| RJ01 | Rejection of invention patent application after publication |
Application publication date: 20210625 |
|
| RJ01 | Rejection of invention patent application after publication |