CN114501057B

CN114501057B - Data processing method, storage medium, processor and system

Info

Publication number: CN114501057B
Application number: CN202111556596.XA
Authority: CN
Inventors: 冯一博; 王宏琦; 常率; 杨皓然
Original assignee: Alibaba China Co Ltd
Current assignee: Alibaba China Co Ltd
Priority date: 2021-12-17
Filing date: 2021-12-17
Publication date: 2024-06-14
Anticipated expiration: 2041-12-17
Also published as: CN114501057A

Abstract

The invention discloses a data processing method, a storage medium, a processor and a system. Wherein the method comprises the following steps: obtaining a target request from a target queue, wherein the target queue is used for storing at least one received request, and the target request is used for requesting execution of a target function; responding to the target request, and acquiring a first execution state in a target storage position, wherein the first execution state is the latest execution state of the target function stored in the target storage position in a history period; triggering the target function to execute based on the first execution state to obtain a second execution state of the target function; the second execution state is stored to the target storage location. The invention solves the technical problem of low reliability of function execution.

Description

Data processing method, storage medium, processor and system

Technical Field

The present invention relates to the field of computers, and in particular, to a data processing method, a storage medium, a processor, and a system.

Background

At present, a synchronous calling mode is used when a workflow calls function calculation, the mode can support the function in the process of stopping execution, but if the function execution time is long, the long connection of the workflow to the function calculation can be abnormally interrupted due to network problems, and the technical problem of low reliability of the function execution exists.

In view of the above problems, no effective solution has been proposed at present.

Disclosure of Invention

The embodiment of the invention provides a data processing method, a storage medium, a processor and a system, which are used for at least solving the technical problem of low reliability of function execution.

According to an aspect of an embodiment of the present invention, there is provided a data processing method. The method may include: obtaining a target request from a target queue, wherein the target queue is used for storing at least one received request, and the target request is used for requesting execution of a target function; responding to the target request, and acquiring a first execution state in a target storage position, wherein the first execution state is the latest execution state of the target function stored in the target storage position in a history period; triggering the target function to execute based on the first execution state to obtain a second execution state of the target function; the second execution state is stored to the target storage location.

According to another aspect of the embodiment of the invention, a data processing method is also provided. The method may include: obtaining a target request of the live platform from a target queue, wherein the target queue is used for storing at least one received request, and the target request is used for requesting execution of a target function; responding to the target request, and acquiring a first execution state in a target storage position, wherein the first execution state is the latest execution state of the target function stored in the target storage position in a history period; triggering the target function to execute based on the first execution state to obtain a second execution state of the target function; the second execution state is stored to the target storage location.

According to another aspect of the embodiment of the invention, a data processing method is also provided. The method may include: obtaining a target request of a video playing platform from a target queue, wherein the target queue is used for storing at least one received request, and the target request is used for requesting to execute a target function; responding to the target request, and acquiring a first execution state in a target storage position, wherein the first execution state is the latest execution state of the target function stored in the target storage position in a history period; triggering the target function to execute based on the first execution state to obtain a second execution state of the target function; the second execution state is stored to the target storage location.

According to another aspect of the embodiment of the invention, a data processing method is also provided. The method may include: triggering a target request in response to a first operation instruction acting on an operation interface, wherein the target request is used for requesting a server to execute a target function; and responding to a second operation instruction acting on the operation interface, and displaying the result of a second execution state of the objective function on the operation interface, wherein the second execution state is obtained by the server acquiring from the target queue and responding to the target request, the trigger objective function is executed based on the first execution state stored in the target storage position, and the first execution state is the latest execution state of the objective function stored in the target storage position in the history period.

According to another aspect of the embodiment of the invention, a data processing method is also provided. The method may include: acquiring a target request from a target queue by calling a first interface, wherein the first interface comprises a first parameter, the parameter value of the first parameter is the target request, the target queue is used for storing at least one received request, and the target request is used for requesting execution of a target function; responding to the target request, and acquiring a first execution state in a target storage position, wherein the first execution state is the latest execution state of the target function stored in the target storage position in a history period; triggering the target function to execute based on the first execution state to obtain a second execution state of the target function; storing the second execution state to the target storage location; and outputting a storage result of the second execution state stored to the target storage position by calling a second interface, wherein the second interface comprises a second parameter, and the parameter value of the second parameter is the storage result.

According to another aspect of the embodiment of the invention, a data processing apparatus is also provided. The apparatus may include: a first obtaining unit, configured to obtain a target request from a target queue, where the target queue is configured to store at least one received request, and the target request is configured to request execution of a target function; a second acquiring unit configured to acquire a first execution state at a target storage location in response to a target request, where the first execution state is a latest execution state of a target function stored to the target storage location in a history period; the first execution unit is used for triggering the execution of the objective function based on the first execution state to obtain a second execution state of the objective function; and the first storage unit is used for storing the second execution state to the target storage position.

According to another aspect of the embodiment of the invention, a data processing apparatus is also provided. The apparatus may include: a third obtaining unit, configured to obtain a target request of the live platform from a target queue, where the target queue is configured to store at least one received request, and the target request is configured to request execution of a target function; a fourth obtaining unit configured to obtain, in response to the target request, a first execution state at the target storage location, where the first execution state is a latest execution state of the target function stored to the target storage location in the history period; the second execution unit is used for triggering the execution of the objective function based on the first execution state to obtain a second execution state of the objective function; and the second storage unit is used for storing the second execution state to the target storage position.

According to another aspect of the embodiment of the invention, a data processing apparatus is also provided. The apparatus may include: a fifth obtaining unit, configured to obtain a target request of the video playing platform from a target queue, where the target queue is configured to store at least one received request, and the target request is configured to request execution of a target function; a sixth obtaining unit, configured to obtain, in response to the target request, a first execution state at the target storage location, where the first execution state is a latest execution state of the target function stored to the target storage location in the history period; the third execution unit is used for triggering the execution of the target function based on the first execution state to obtain a second execution state of the target function; and the third storage unit is used for storing the second execution state to the target storage position.

According to another aspect of the embodiment of the invention, a data processing apparatus is also provided. The apparatus may include: the first triggering unit is used for responding to a first operation instruction acted on the operation interface and triggering a target request, wherein the target request is used for requesting the server to execute a target function; the first display unit is used for responding to a second operation instruction acting on the operation interface and displaying a result of a second execution state of the objective function on the operation interface, wherein the second execution state is obtained by the server from the target queue and responding to the target request, the trigger objective function is executed based on a first execution state stored in the target storage position, and the first execution state is the latest execution state of the objective function stored in the target storage position in a history period.

According to another aspect of the embodiment of the invention, a data processing apparatus is also provided. The apparatus may include: a seventh obtaining unit, configured to obtain a target request from a target queue by calling a first interface, where the first interface includes a first parameter, a parameter value of the first parameter is a target request, the target queue is used to store at least one received request, and the target request is used to request to execute a target function; an eighth obtaining unit, configured to obtain, in response to the target request, a first execution state at the target storage location, where the first execution state is a latest execution state of the target function stored to the target storage location in the history period; the fourth execution unit is used for triggering the execution of the target function based on the first execution state to obtain a second execution state of the target function; a fourth storage unit for storing the second execution state to the target storage location; and the output unit is used for outputting a storage result of the second execution state stored to the target storage position by calling the second interface, wherein the second interface comprises a second parameter, and the parameter value of the second parameter is the storage result.

According to another aspect of the embodiments of the present invention, there is also provided a computer readable storage medium, including a stored program, wherein the program when run controls a device in which the storage medium is located to perform the method of data processing of any one of the above.

According to another aspect of an embodiment of the present invention, there is also provided a data processing system including: a processor; a memory coupled to the processor for providing instructions to the processor for processing the steps of: obtaining a target request from a target queue, wherein the target queue is used for storing at least one received request, and the target request is used for requesting execution of a target function; responding to the target request, and acquiring a first execution state in a target storage position, wherein the first execution state is the latest execution state of the target function stored in the target storage position in a history period; triggering the target function to execute based on the first execution state to obtain a second execution state of the target function; the second execution state is stored to the target storage location.

In the embodiment of the invention, a target request is acquired from a target queue, wherein the target queue is used for storing at least one received request, and the target request is used for requesting to execute a target function; responding to the target request, and acquiring a first execution state in a target storage position, wherein the first execution state is the latest execution state of the target function stored in the target storage position in a history period; triggering the target function to execute based on the first execution state to obtain a second execution state of the target function; the second execution state is stored to the target storage location. That is, the invention adopts the asynchronous call method with function calculation state, and realizes the state conversion without going through again from the beginning, the state recovery and the message reentry by providing the trigger target function based on the first execution state execution, thereby ensuring the uniqueness of the system task scheduling, further realizing the technical effect of improving the reliability of the function execution, and solving the technical problem of low reliability of the function execution.

Drawings

The accompanying drawings, which are included to provide a further understanding of the application and are incorporated in and constitute a part of this specification, illustrate embodiments of the application and together with the description serve to explain the application and do not constitute a limitation on the application. In the drawings:

Fig. 1 is a block diagram of a hardware structure of a computer terminal (or mobile device) of a data processing method according to an embodiment of the present invention;

FIG. 2 is a flow chart of a data processing method according to an embodiment of the invention;

FIG. 3 is a flow chart of another data processing method according to an embodiment of the present invention;

FIG. 4 is a flow chart of another data processing method according to an embodiment of the present invention;

FIG. 5 is a flow chart of another data processing method according to an embodiment of the present invention;

FIG. 6 is a flow chart of another data processing method according to an embodiment of the invention;

FIG. 7 is a schematic diagram of an asynchronous task execution state machine according to an embodiment of the present invention;

FIG. 8 is a schematic diagram of a data processing overall framework in accordance with an embodiment of the present invention;

FIG. 9 is a schematic diagram of an inter-component interaction relationship according to an embodiment of the present invention;

FIG. 10 is a schematic diagram of a data processing apparatus according to an embodiment of the present invention;

FIG. 11 is a schematic diagram of another data processing apparatus according to an embodiment of the present invention;

FIG. 12 is a schematic diagram of another data processing apparatus according to an embodiment of the present invention;

FIG. 13 is a schematic diagram of another data processing apparatus according to an embodiment of the present invention;

FIG. 14 is a schematic diagram of another data processing apparatus according to an embodiment of the invention;

fig. 15 is a block diagram of a computer terminal according to an embodiment of the present invention.

Detailed Description

In order that those skilled in the art will better understand the present invention, a technical solution in the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings in which it is apparent that the described embodiments are only some embodiments of the present invention, not all embodiments. All other embodiments, which can be made by those skilled in the art based on the embodiments of the present invention without making any inventive effort, shall fall within the scope of the present invention.

It should be noted that the terms "first," "second," and the like in the description and the claims of the present invention and the above figures are used for distinguishing between similar objects and not necessarily for describing a particular sequential or chronological order. It is to be understood that the data so used may be interchanged where appropriate such that the embodiments of the invention described herein may be implemented in sequences other than those illustrated or otherwise described herein. Furthermore, the terms "comprises," "comprising," and "having," and any variations thereof, are intended to cover a non-exclusive inclusion, such that a process, method, system, article, or apparatus that comprises a list of steps or elements is not necessarily limited to those steps or elements expressly listed but may include other steps or elements not expressly listed or inherent to such process, method, article, or apparatus.

First, partial terms or terminology appearing in the course of describing embodiments of the application are applicable to the following explanation:

function calculation, which is an event-driven full support calculation service, is performed by a function calculation, a user does not need to manage infrastructure such as a server and the like, only needs to write codes and upload the codes, the function calculation can prepare corresponding calculation resources, the user codes are operated in an elastic and reliable mode, and the functions such as log inquiry, performance monitoring and alarm are provided;

Asynchronous call, a function calculation call mode, wherein an event returns a result after being written into a function calculation internal queue, and a function calculation system can ensure that the message is reliably processed and the function is correctly executed;

Exactly once (Exactly Once), one of the message transfer mechanisms means that each message is one and only once, i.e. the message processing is neither lost nor repeated, here it means that each asynchronous execution function request by a user is triggered only once.

Example 1

There is also provided, in accordance with an embodiment of the present invention, an embodiment of a data processing method, it being noted that the steps shown in the flowchart of the figures may be performed in a computer system, such as a set of computer executable instructions, and, although a logical order is shown in the flowchart, in some cases, the steps shown or described may be performed in an order other than that shown or described herein.

The method according to the first embodiment of the present application may be implemented in a mobile terminal, a computer terminal or a similar computing device. Fig. 1 shows a block diagram of a hardware architecture of a computer terminal (or mobile device) for implementing a data processing method. As shown in fig. 1, the computer terminal 10 (or mobile device 10) may include one or more (shown as 102a, 102b, … …,102 n) processors 102 (the processors 102 may include, but are not limited to, a microprocessor MCU, a programmable logic device FPGA, etc. processing means), a memory 104 for storing data, and a transmission means 106 for communication functions. In addition, the method may further include: a display, an input/output interface (I/O interface), a Universal Serial Bus (USB) port (which may be included as one of the ports of the I/O interface), a network interface, a power supply, and/or a camera. It will be appreciated by those of ordinary skill in the art that the configuration shown in fig. 1 is merely illustrative and is not intended to limit the configuration of the electronic device described above. For example, the computer terminal 10 may also include more or fewer components than shown in FIG. 1, or have a different configuration than shown in FIG. 1.

It should be noted that the one or more processors 102 and/or other data processing circuits described above may be referred to generally herein as "data processing circuits. The data processing circuit may be embodied in whole or in part in software, hardware, firmware, or any other combination. Furthermore, the data processing circuitry may be a single stand-alone processing module, or incorporated, in whole or in part, into any of the other elements in the computer terminal 10 (or mobile device). As referred to in embodiments of the application, the data processing circuit acts as a processor control (e.g., selection of the path of the variable resistor termination connected to the interface).

The memory 104 may be used to store software programs and modules of application software, such as program instructions/data storage devices corresponding to the data processing method in the embodiment of the present invention, and the processor 102 executes the software programs and modules stored in the memory 104, thereby executing various functional applications and data processing, that is, implementing the data processing method of the application program. Memory 104 may include high-speed random access memory, and may also include non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid-state memory. In some examples, the memory 104 may further include memory located remotely from the processor 102, which may be connected to the computer terminal 10 via a network. Examples of such networks include, but are not limited to, the internet, intranets, local area networks, mobile communication networks, and combinations thereof.

The transmission means 106 is arranged to receive or transmit data via a network. The specific examples of the network described above may include a wireless network provided by a communication provider of the computer terminal 10. In one example, the transmission device 106 includes a network adapter (Network Interface Controller, NIC) that can connect to other network devices through a base station to communicate with the internet. In one example, the transmission device 106 may be a Radio Frequency (RF) module for communicating with the internet wirelessly.

The display may be, for example, a touch screen type Liquid Crystal Display (LCD) that may enable a user to interact with a user interface of the computer terminal 10 (or mobile device).

It should be noted here that, in some alternative embodiments, the computer device (or mobile device) shown in fig. 1 described above may include hardware elements (including circuitry), software elements (including computer code stored on a computer-readable medium), or a combination of both hardware and software elements. It should be noted that fig. 1 is only one example of a specific example, and is intended to illustrate the types of components that may be present in the computer device (or mobile device) described above.

In the operating environment shown in FIG. 1, the present application provides a data processing method as shown in FIG. 2. It should be noted that, the data processing method of this embodiment may be performed by the mobile terminal of the embodiment shown in fig. 1.

Fig. 2 is a flow chart of a data processing method according to an embodiment of the present invention. As shown in fig. 2, the method may include the steps of:

step S202, obtaining a target request from a target queue, where the target queue is used to store the received at least one request, and the target request is used to request execution of an objective function.

In the technical solution provided in the above step S202 of the present invention, a target request is obtained from a target queue storing a plurality of requests, and a target function corresponding to the target request is executed based on the target request, where the target request corresponds to the target function and may be used to request execution of the target function for data processing, and the target request may be a request in function execution, may be a request sent by a user equipment, may be a control class request, or the like; the objective function may be a user-defined function, and a function corresponding to the objective request in the cluster may be calculated for the function.

Optionally, a control class request of the user equipment is obtained, an application program portal (api-server) finds a machine currently responsible for the execution through a service load balancing component, the request is transmitted to a corresponding machine, and after the machine receives the control class request, the machine intervenes in the execution of the state machine to execute an objective function, thereby completing the processing of the control request.

In step S204, in response to the target request, a first execution state is acquired at the target storage location, where the first execution state is a latest execution state of the target function stored to the target storage location during the history period.

In the technical solution provided in the above step S204 of the present invention, in response to a target request, the latest execution state of the target function stored in the target Storage location during the history period is obtained in the target Storage location, where the target Storage location may be a Remote Storage location (Remote Storage) of the user; the first execution state may be a latest execution state of the objective function stored to the target storage location during the history period, and may be a state before the hardware failure.

Optionally, when the target request arrives, it is determined what operation should be performed by the service according to the current state, so that the execution data output by the target engine, for example, if the task is in the state of the dequeue function (dequeue), i.e., the first function in the specified queue of each matching element is removed and the removed function is executed, the next state conversion correspondingly converts the first function into the running (running) state, and executes the conversion logic, requests an instance, and triggers execution, so as to obtain the execution data output by the target engine, where the execution data includes the call parameter of the user function, the triggering time, and other metadata, and the execution state of the function may also be included in the execution data.

Optionally, the Execution engine is scheduled to start an Execution, the Execution engine firstly stores the Execution data in the remote storage of the user, acquires the first Execution state associated with the Execution data at the target storage location, then triggers an actual Execution of the user function, and updates the latest Execution state to the remote storage of the user at any time during the Execution, wherein the Execution engine (Execution ENGINE AGENT) can be used for executing the data.

Alternatively, if execution is interrupted due to a hardware failure, the execution engine may repeatedly turn on execution once, acquire a record of the execution state in the remote storage of the user, and thus acquire the latest execution state stored in the history period by the target storage location, that is, acquire the first execution state (state before the hardware failure) associated with the execution data in the target storage location (in the remote storage of the user).

In step S206, the objective function is triggered to execute based on the first execution state, resulting in a second execution state of the objective function.

In the technical solution provided in the above step S208 of the present invention, if the execution is interrupted due to the hardware failure at this time, the execution is repeatedly triggered to obtain the record about the execution state in the remote storage, thereby obtaining the latest execution state stored before the failure, and further obtaining the second execution state of the objective function.

Step S208, the second execution state is stored to the target storage location.

In the technical solution provided in the above step S210 of the present invention, the second execution state is stored in the target storage location, and then the actual execution of the user function is triggered once, so that the state before the hardware failure is restored for execution.

Optionally, a state machine model is introduced at the system scheduling side to drive the whole execution based on the state, and the state change of the whole state machine is recorded in the persistent storage for the user to check, so that after the information reappears, corresponding operation is continued according to the recorded information without carrying out state conversion from the beginning again, thereby realizing state recovery and information re-entry, storing the second execution state in a target storage position, and when the system fails again, starting conversion of the second execution state without carrying out state conversion from the beginning again, thereby realizing state recovery and information re-entry, and ensuring the uniqueness of the system task scheduling.

Through the steps S202 to S208 of the present application, a target request is obtained from a target queue, where the target queue is used to store at least one received request, and the target request is used to request execution of a target function; responding to the target request, and acquiring a first execution state in a target storage position, wherein the first execution state is the latest execution state of the target function stored in the target storage position in a history period; triggering the target function to execute based on the first execution state to obtain a second execution state of the target function; the second execution state is stored to the target storage location. That is, the application adopts the asynchronous call method with function calculation state, and realizes the state conversion without going through again from the beginning, the state recovery and the message reentry by providing the trigger target function based on the first execution state execution, thereby ensuring the uniqueness of the system task scheduling, further realizing the technical effect of improving the reliability of the function execution, and solving the technical problem of low reliability of the function execution.

The above-described method of this embodiment is further described below.

As an optional implementation manner, step S202, obtaining the target request includes: and if the target function is determined to interrupt execution, acquiring a target request.

In this embodiment, if the execution is interrupted, the execution engine will trigger the execution again, and after the target request is obtained, the function of the user will obtain a record of the execution state stored in the target storage location, so as to obtain the target request immediately before the interruption of the target function, where the interruption execution of the target function may be an interruption of the execution caused by a hardware fault, for example, an interruption caused by a system self fault, a user code fault, or a restart.

As an alternative embodiment, determining that the objective function interrupts execution includes: and triggering the target function to interrupt execution if the first target device is in the abnormal state, wherein the first target device is used for triggering the target function to execute so as to obtain a first execution state.

In this embodiment, the first target device may be a machine responsible for executing the target function, and may calculate a dependent third party service for the function; the abnormal state can be a state that one machine is down or restarted, or a state that a message caused in a scene of down restarting of the whole function computing system appears for a plurality of times.

Optionally, the function computing cluster has a Partition logic concept, the Partition is a basic scheduling unit of service load balancing (multi-lease management), the same service has a group of machines of the same model, any one of the machines can be responsible for processing other partitions of the same service, each Partition is responsible for processing requests of multiple users, each machine in an asynchronous calling component of the system is responsible for 1-n partitions and monitors a user queue of the corresponding Partition, when one machine is down or restarted, the Partition responsible for the machine is picked up by the other machines, thereby triggering the target function of the first target device in an abnormal state to interrupt execution, determining that the first target device is in the abnormal state, triggering the target function to interrupt execution by the first target device, and acquiring an execution record in a target storage position by the first target device, thereby acquiring a first execution state.

As an alternative embodiment, the obtaining the target request includes: and monitoring a target request based on the second target device, wherein the model of the second target device is the same as the model of the first target device.

In this embodiment, the model of the second target device is the same as the model of the first target device, and the target request sent by the second target device with the same model is obtained, and may be that the same message of the user reappears, and then the target request is obtained.

Optionally, the same service has a batch of machines of the same machine type, any one of the machines can be responsible for other slicing processing of the same service, and after the information of the machines of the same machine type appears again, the target request of the second target device is acquired through state recovery and reentrant design of the state machine, so that the normal processing of the execution of the target function is ensured.

As an alternative embodiment, before the target request is monitored based on the second target device, the method further comprises: based on the first target device monitoring the target request; responding to the target request, triggering the target function to execute, and obtaining a first execution state; the first execution state is stored to the target storage location.

In this embodiment, when a target request of a first target device is monitored, a state machine model determines what operation should be performed according to a current state, so as to trigger execution of a target function, and obtain a first execution state, where the state machine model may be introduced from a general scheduling side, may be used for performing an entire execution, implement state-based driving, and solve problems of persistence of an execution state and state management based on scheduling of a state machine.

Optionally, the first target device repeatedly triggers the same execution engine, and then uses the same execution layer to execute the task, and each time the user function is triggered to actually execute, the state change (the first execution state) is recorded in the persistent storage (stored to the target storage location), so as to ensure the persistence of the execution state and the state management problem.

As an alternative embodiment, triggering the execution of the objective function, to obtain a first execution state, includes: and triggering the execution of the target function to obtain a first execution state if the execution state of the target function is not stored in the target storage position.

In this embodiment, the execution of the objective function is triggered, and it is determined that the execution state of the objective function is not stored in the objective storage location first, if yes, the objective function stored in the objective storage location is executed first to obtain the first execution state, and if no, the execution of the objective function is triggered to obtain the first execution state.

As an alternative embodiment, triggering the execution of the objective function based on the first execution state results in a second execution state of the objective function, including: determining that the first execution state is a state of the target function which is not executed, determining a first target operation, and triggering the target function to execute the first target operation to obtain a second execution state; and determining that the first execution state is used for representing the executed state of the objective function, determining a second objective operation based on the executed state, and triggering the objective function to execute the second objective operation to obtain the second execution state.

In this embodiment, if it is determined that the first execution state is a state in which the objective function is not executed, determining a first target operation, and triggering the objective function to execute based on the first execution state, to obtain a second execution state; if the first execution state is determined to be used for representing the executed state of the objective function, determining a second objective operation based on the executed state, and triggering the objective function to execute the second objective operation to obtain the second execution state, wherein the first objective operation can be the operation executed for the first time, and the execution data only carries out corresponding operation according to the current state, so that message deduplication is realized.

Alternatively, there are a number of states of execution, which may include: before execution (enqueued) for indicating an unexecuted state; in execution (running) for indicating a state of being executed; after execution (succeeded/failed), it is used to indicate that the execution is completed, and it should be noted that the execution state of the function is irrelevant to whether the function is executed or not.

As an alternative embodiment, acquiring the first execution state at the target storage location includes: a first execution state is retrieved from a target storage location based on a target toolkit associated with the target function.

In this embodiment, the target toolkit may be a fast-packaged software development toolkit (Software Development Kit, abbreviated as SDK), and may include two fast-packaged software development toolkits of an in-table data add column and an acquisition record, and may be used to store multiple target functions, because of the existence of the software development toolkit, it is realized that a user (function) synchronizes an additional record when executing, so that even under the scenarios of restarting a virtual machine, failing to execute by the user, etc., the user side may retry to recover to a state before failing according to an intermediate state of execution, and a first execution state when the target toolkit stores the execution data of the runtime system is acquired, thereby realizing reentrant of functional logic inside the function through recording and reprocessing of the state.

Optionally, after the user gives the function computation service role table storage read-write authority and turns on the stateful asynchronous call strong state switch, the function computation execution layer will attempt to create an external table (OTS) under the user account when starting to call the user container, in which table the user can optionally persist the state with other external storage that has been supported. Meanwhile, the function calculation provides two quick encapsulation software development kits of adding columns and acquiring records of data in a table in a Runtime system (run time), and allows the objective function to synchronize the newly added records during execution, so that the user side can retry according to the state before the execution intermediate state is restored to the state before the failure even under the scenes of restarting the virtual machine, failure of the user execution and the like.

As an alternative embodiment, triggering the execution of the objective function based on the first execution state results in a second execution state of the objective function, including: triggering the target function to execute based on the first execution state based on the call information to obtain a second execution state.

In this embodiment, the execution data output by the target engine may include metadata such as a call parameter, a trigger time, and the like of the user function, so that the target engine triggers the execution of the target function in the user container based on the first execution state by calling metadata information, and obtains the second execution state.

The embodiment of the invention also provides another data processing method of the live broadcast platform.

Fig. 3 is a flow chart of another data processing method according to an embodiment of the present invention. As shown in fig. 3, the method may include the following steps.

In step S302, a target request of the live platform is obtained from a target queue, where the target queue is used to store the received at least one request, and the target request is used to request execution of a target function.

In the technical solution provided in the above step S302 of the present invention, a target request is obtained from a target queue storing a plurality of requests, and a target function corresponding to the target request is executed based on the target request, where the target request may be a request in function execution, a request sent by a live platform, a control class request, and so on.

Optionally, the target request sent by the live broadcast platform is obtained, the execution machine currently responsible for the target request is found through the load balancing component, the target request is sent to the corresponding machine, and after the machine receives the target request of the live broadcast platform, the machine intervenes in the execution of the state machine to execute the target function corresponding to the target request of the live broadcast platform.

In step S304, in response to the target request, a first execution state is acquired at the target storage location, where the first execution state is a latest execution state of the target function stored to the target storage location in the history period. .

In the technical scheme provided in the above step S304 of the present invention, in response to the target request sent by the live broadcast platform, the latest Execution state of the target function stored in the target storage location in the history period is obtained in the target storage location, and in response to the target request scheduling component (System Scheduling components), the Execution engine (Execution ENGINE AGENT) is scheduled to be started for one time for Execution, and the Execution engine firstly stores the Execution data in the remote storage of the user, so as to achieve the purpose of obtaining the Execution data output by the Execution engine of the live broadcast platform.

In step S306, the objective function is triggered to execute based on the first execution state, resulting in a second execution state of the objective function.

In the technical solution provided in step S306, if the execution is interrupted at this time, the execution is repeatedly triggered, and the user function obtains the record about the execution state in the target storage location, thereby obtaining the first execution state, triggering the target function to execute based on the first execution state, obtaining the second execution state of the target function, and enabling the machine to resume to the previous state for execution.

Step S308, storing the second execution state to the target storage location.

In the technical solution provided in step S308, because each state change of the state machine is recorded, the user function stores the second execution state in the target storage location, thereby storing the latest execution state of the history period target function in the target storage location.

The embodiment of the invention also provides another data processing method.

Fig. 4 is a flow chart of another data processing method according to an embodiment of the present invention. As shown in fig. 4, the method may include the following steps.

Step S402, obtaining a target request of the video playing platform from a target queue, where the target queue is used to store the received at least one request, and the target request is used to request to execute an objective function.

In step S404, in response to the target request, a first execution state is acquired at the target storage location, where the first execution state is a latest execution state of the target function stored to the target storage location during the history period.

In step S406, the objective function is triggered to execute based on the first execution state, resulting in a second execution state of the objective function.

In step S408, the second execution state is stored in the target storage location.

The embodiment of the invention also provides another data processing method.

FIG. 5 is a flow chart of another data processing method according to an embodiment of the present invention. As shown in fig. 5, the method may include the steps of:

In step S502, in response to a first operation instruction acting on the operation interface, a target request is triggered, where the target request is used to request the server to execute the target function.

In the technical solution provided in the above step S502 of the present invention, the first operation instruction may be triggered by a user and is used to trigger the target request, so that the embodiment responds to the first operation instruction acting on the interactive interface, obtains the execution data output by the target engine, and requests the execution of the target function from the server.

In step S504, in response to a second operation instruction acting on the operation interface, a result of a second execution state of the objective function is displayed on the operation interface, where the second execution state is obtained by the server obtaining from the target queue and responding to the target request, and the objective function is triggered to be executed based on a first execution state associated with the execution data stored in the target storage location, and the first execution state is a latest execution state of the objective function stored in the target storage location in the history period.

In the technical solution provided in the above step S504, a result of the second execution state of the objective function is displayed on the operation interface in response to the second operation instruction acting on the operation interface, where the result of the second execution state may be obtained by executing the first execution state stored in the target storage location.

The embodiment of the invention also provides another data processing method.

FIG. 6 is a flow chart of another data processing method according to an embodiment of the present invention. As shown in fig. 6, the method may include the steps of:

In step S602, a target request is obtained from a target queue by calling a first interface, where the first interface includes a first parameter, a parameter value of the first parameter is a target request, the target queue is used to store at least one received request, and the target request is used to request execution of a target function.

In the technical solution provided in step S602 of the present invention, the first interface may be an interface for performing data interaction between the server and the client. The client may transmit at least one load to the first interface as a first parameter of the first interface, so as to achieve the purpose of uploading the target load to the server.

In step S604, in response to the target request, execution data output by the target engine is acquired.

In step S606, a first execution state associated with the execution data is acquired at the target storage location, where the first execution state is a latest execution state of the objective function stored to the target storage location during the history period.

Step S608, triggering the execution of the objective function based on the first execution state, to obtain a second execution state of the objective function; the second execution state is stored to the target storage location.

In step S610, the second interface is called to output the storage result of the second execution state stored in the target storage location, where the second interface includes a second parameter, and a parameter value of the second parameter is the storage result.

In the technical solution provided in the above step S610 of the present invention, the second interface may be an interface for performing data interaction between the server and the client, and the server may output the storage result of the second execution state stored in the target storage location by calling the second interface, where the second parameter is used as a parameter of the second interface, so as to achieve the purpose of storing the result of the second execution state.

In this embodiment, the target request is used to request execution of the target function by retrieving the target request from a target queue, wherein the target queue is used to store the received at least one request; responding to the target request, and acquiring a first execution state in a target storage position, wherein the first execution state is the latest execution state of the target function stored in the target storage position in a history period; triggering the target function to execute based on the first execution state to obtain a second execution state of the target function; the second execution state is stored to the target storage position, so that state conversion can not be carried out from beginning to end, state recovery and information can be reentered, the uniqueness of system task scheduling is guaranteed, the technical effect of improving the reliability of function execution is further achieved, and the technical problem of low reliability of function execution is solved.

Example 2

The preferred implementation of the above method of this embodiment is further described below, specifically in terms of asynchronous call with state of function computation.

Early developments of serverless computing (Functions AS A SERVICE, abbreviated FaaS) were mainly supporting stateless, short-time, lightweight computing capabilities, such as application program interface backend, picture processing, data streaming processing, etc. In various scenarios, the calling modes for the serverless computing function can be divided into two categories: asynchronous calls and synchronous calls. The biggest difference between the two is that: synchronous calls will directly request the container for function execution, while asynchronous calls will immediately return to the caller (202 HttpCode) and enqueue asynchronous call messages for queuing processing by the backend service.

In the early stage of function development, the target client of asynchronous call is often an offline function scene which is insensitive to delay and can have a large amount of sudden increase flow, and the method can effectively reduce the impact of the outside on the system and the downstream functions of the user functions.

However, as functionality evolves, some clients of the online live scenario migrate to serverless computing as well. The functions often have longer execution time, such as push stream and video processing functions, the functions always run in the whole live broadcast process, the functions have extremely high requirements on reliability, the functions are required to be capable of sensing the state of the functions in real time, the functions are executed in real time, and due to the fact that the stability of long connection is poor and the problems of occupying client resources and the like, the functions often cannot be called synchronously.

In the related art, there is a scheme that the user's needs can be partially met by managing the function execution state through a serverless workflow using the currently existing service, but the scheme has several disadvantages as follows: the function needs to be split so that the workflow can be arranged, and therefore, when the function is not suitable for splitting, for example, an online live broadcast plug flow scene, the workflow cannot achieve good state management; the operation of the workflow on the function executed for a long time can be abnormal due to network reasons, a synchronous calling mode is used when the workflow calls the function calculation, the mode can support the function in the execution suspension, but if the function execution time is long, the long connection of the workflow to the function calculation can be abnormal due to network problems; the message processing semantics of the workflow are at least one time (at least once), and a certain step or function of a user can be repeatedly triggered and executed for a plurality of times, so that the mode is inapplicable to an online live broadcast scene; task scheduling among steps is cross-service, scheduling in a process and the like are poor in performance.

Therefore, the embodiment expands the concept and the application range of 'call-on-request' in the server-free computing, and stateful asynchronous call is expanded as a new form of the asynchronous call mode of function computing, so that the requirements of users on observability, operability and reliability of asynchronous call can be effectively solved, online long-term tasks such as live broadcasting, video processing, deep learning reasoning and the like can be better supported, higher usability guarantee is provided for online application scenes, stateful asynchronous call functions are introduced, various scenes are better supported, meanwhile, an implementation scheme of strictly once (Exactly Once) in a server-free system is provided for the problem of message 'accuracy' focused by the video processing functions, namely, the events can ensure that all operators in the streamed application program are processed strictly once even if various failures are encountered, and the reliability of user execution is ensured.

The above-described method of this embodiment is further described below.

This embodiment employs a state checkpoint (check point) to resolve the observability of the user for asynchronous execution, i.e., state save, and control requirements, which may include: on the basis of a state check point, a state machine model is introduced, a message receiving (receiving) mechanism is used for at least one time, and the reentrant of a key part is added, so that the message processing is guaranteed to be in a strict once semantic, meanwhile, a software development kit user providing a running layer (run) can conveniently use the software development kit to store the running execution state, and the reentrant of the function internal functional logic is realized through recording and reprocessing the state, wherein the state machine model can be an internal control model and is embodied as a map, and the state check point is mainly stored for the states, so that the observability requirement of the user is realized.

The key points of the embodiment mainly include the following aspects: performing persistence of the state, state management and scheduling; the "strict once" semantics of message processing: the third party relies on/the system itself to recover and dispatch (high availability) the state under the fault/user code fault/restart scenario; the container controls, stopping the request in execution, i.e., multi-tenant service discovery, which is a service discovery mechanism that is used uniformly by the components of the system. The identity (accountID) of the user is subjected to consistent hashing, so that an actual state machine responsible for the user request is found, the execution state of the state machine is further interfered, and the requirement of the user on controlling the container is met.

The above-described points of this embodiment are further described below.

First, persistence of the execution state, state management and scheduling. The scheduling based on the state machine solves the problems of persistence of the execution state and state management, one execution of the user is divided into a plurality of states, and when a message arrives, what operation the service should perform is judged according to the current state. FIG. 7 is a schematic diagram of an asynchronous task execution state machine according to an embodiment of the present invention, as shown in FIG. 7, where a state machine model is introduced at the system dispatch side to perform state-based driving of the entire execution, such as the task being in a dequeue function (dequeue) for removing the first function in the specified queue of each matching element and executing the removed function), then the next state transition corresponds to transitioning it to a reserved successful state and starting to run, while the transition logic is executed: an instance is requested and execution is triggered.

Meanwhile, due to the introduction of the state machine, the unique task ID can be effectively de-duplicated, so that the uniqueness of system task scheduling can be ensured even when the condition of restarting and downtime occurs to a message queue (a third party service on which function calculation depends) and the condition of de-duplication occurs for a plurality of times in a scene of restarting the whole function calculation system, and the database can be recorded after each execution is triggered by a user. Therefore, even if the same message appears multiple times in our system, it corresponds to one record of execution.

Second, state recovery under failure/restart and scheduled re-entrant and container control. FIG. 8 is a schematic diagram of an overall framework of data processing according to an embodiment of the present invention, where after the user's message reappears as shown in FIG. 8, normal processing of the user's function is guaranteed by state recovery and re-entrant design of the state machine.

Because each state change of the state machine is recorded, the corresponding operation is continued according to the recorded message after the message reappears, and the state transition is not performed from the beginning. Thus achieving state recovery and message re-entry. After receiving the control class request, the machine will intervene in the execution of the state machine to complete the processing of the control request, which may be to monitor the content message (context) through the state opportunity to stop at any time.

3. The execution component coordinates with the scheduling component in multiple parties, and the execution system level state persistence capability ensures strict one-time semantics of task processing. FIG. 9 is a schematic diagram of an inter-component interaction relationship according to an embodiment of the present invention, as shown in FIG. 9, where the execution engine first stores execution data in the user's remote store, and then triggers an actual execution of the user's function. The user function will save the runtime program to the user's remote store at any time during execution. If the execution is interrupted at this time due to hardware failure, the scheduling component may trigger the execution once repeatedly, and the function of the user may acquire a record about the execution state in the remote storage of the user, and then resume to the state before the hardware failure for execution.

Different services are provided at the dispatch layer and the execution layer, so that although the dispatch layer uses a state machine model, if the dispatch layer and the execution layer have network partitions in the execution process, the dispatch layer can recall the same execution layer to execute tasks after the tasks are recovered; at this time, the execution layer recognizes the request as an executing request because of performing the task persistence operation, and does not trigger an actual execution again.

The state management scheme of the scheduling layer ensures that tasks caused by operation failure and message repetition in most cases are repeatedly executed, but in some extreme cases, if the scheduling layer and the execution layer restart due to system problems at the same time, repeated execution of the messages is possible, and additional optional function guarantee is added. When the user gives the function computing service role table storage read-write authority and opens the stateful asynchronous call strong state switch, the function computing Execution layer (Execution Engine) will attempt to create an OTS table under the user account (other external storage optionally supported by the user, such as NAS, etc.) when starting to call the user container, and persist the state. Meanwhile, the function calculation provides two fast encapsulation SDKs of adding columns to the data in the table and acquiring records in the running system, and allows a user (function) to synchronize the newly added records when executing. Thus, even if the user is restarted or the user fails to execute, the user side can retry according to the state before the execution intermediate state is restored to the failure.

According to the embodiment, aiming at the observability, operability and reliability requirements of a user for a single request without a server, a stateful asynchronous call scheme is provided, and 'strict one-time' semantics of message processing are ensured by 'scheduling module task state machine plus asynchronous message (RECEIVE AT LEAST on) plus key point state re-entry plus running state check point support'.

Stateful asynchronous calls provide function-level granularity execution state preservation, addressing the needs of users for long-time, non-detachable function observability and operability. Moreover, the executing state in execution can be checked, the operation is performed, the history execution is traceable, the message processing of 'strict once' semantics can be realized by using the stateful asynchronous call, and the function execution of a user can be ensured not to be influenced in the system restarting caused by unexpected faults.

It should be noted that, for simplicity of description, the foregoing method embodiments are all described as a series of acts, but it should be understood by those skilled in the art that the present invention is not limited by the order of acts described, as some steps may be performed in other orders or concurrently in accordance with the present invention. Further, those skilled in the art will also appreciate that the embodiments described in the specification are all preferred embodiments, and that the acts and modules referred to are not necessarily required for the present invention.

From the above description of the embodiments, it will be clear to those skilled in the art that the resource allocation method according to the above embodiments may be implemented by means of software plus necessary general hardware platform, but of course also by means of hardware, but in many cases the former is a preferred embodiment. Based on such understanding, the technical solution of the present invention may be embodied essentially or in a part contributing to the prior art in the form of a software product stored in a storage medium (e.g. ROM/RAM, magnetic disk, optical disk) comprising instructions for causing a terminal device (which may be a mobile phone, a computer, a server, or a network device, etc.) to perform the method according to the embodiments of the present invention.

Example 3

According to an embodiment of the present invention, there is also provided a data processing apparatus for implementing the data processing method shown in fig. 2.

Fig. 10 is a schematic diagram of a data processing apparatus according to an embodiment of the present invention. As shown in fig. 10, the data processing apparatus 1000 may include: a first acquisition unit 1002, a second acquisition unit 1004, a first execution unit 1006, and a first storage unit 1008.

The first obtaining unit 1002 is configured to obtain a target request from a target queue, where the target queue is used to store at least one received request, and the target request is used to request to execute an objective function.

The second obtaining unit 1004 is configured to obtain a first execution state at the target storage location, where the first execution state is a latest execution state of the objective function stored to the target storage location in the history period.

The first execution unit 1006 is configured to trigger the execution of the objective function based on the first execution state, and obtain a second execution state of the objective function.

A first storage unit 1008 for storing the second execution state to the target storage location.

Here, it should be noted that the first acquiring unit 1002, the second acquiring unit 1004, the first executing unit 1006, and the first storing unit 1008 correspond to steps S202 to S208 in embodiment 1, and the four units are the same as the examples and application scenarios implemented by the corresponding steps, but are not limited to the disclosure of the first embodiment. It should be noted that the above-described unit may be operated as a part of the apparatus in the computer terminal 10 provided in the first embodiment.

According to an embodiment of the present invention, there is also provided a data processing apparatus for implementing the data processing method shown in fig. 3.

Fig. 11 is a schematic diagram of another data processing apparatus according to an embodiment of the present invention. As shown in fig. 11, the data processing apparatus 1100 may include: a third acquisition unit 1102, a fourth acquisition unit 1104, a second execution unit 1106, and a second storage unit 1108.

A third obtaining unit 1102, configured to obtain a target request of the live platform from a target queue, where the target queue is used to store the received at least one request, and the target request is used to request to execute an objective function.

A fourth obtaining unit 1104, configured to obtain, in response to the target request, a first execution state at the target storage location, where the first execution state is a latest execution state of the target function stored to the target storage location during the history period.

The second execution unit 1106 is configured to trigger the execution of the objective function based on the first execution state, so as to obtain a second execution state of the objective function.

A second storage unit 1108 is configured to store the second execution state to the target storage location.

It should be noted that the third acquiring unit 1102, the fourth acquiring unit 1104, the second executing unit 1106 and the second storing unit 1108 correspond to steps S302 to S308 in embodiment 1, and the four units are the same as the corresponding steps in terms of implementation and application, but are not limited to the disclosure of the first embodiment. It should be noted that the above-described unit may be operated as a part of the apparatus in the computer terminal 10 provided in the first embodiment.

According to an embodiment of the present invention, there is also provided a data processing apparatus for implementing the data processing method shown in fig. 4.

Fig. 12 is a schematic diagram of another data processing apparatus according to an embodiment of the present invention. As shown in fig. 12, the data processing apparatus 1200 may include: a fifth acquisition unit 1202, a sixth acquisition unit 1204, a third execution unit 1206, and a third storage unit 1208.

A fifth obtaining unit 1202 is configured to obtain a target request of the video playing platform from a target queue, where the target queue is used to store the received at least one request, and the target request is used to request to execute an objective function.

A sixth obtaining unit 1204, configured to obtain, in response to the target request, a first execution state at the target storage location, where the first execution state is a latest execution state of the target function stored to the target storage location during the history period.

The third execution unit 1206 is configured to trigger the execution of the objective function based on the first execution state, resulting in a second execution state of the objective function.

A third storage unit 1208 for storing the second execution state to the target storage location.

Here, it should be noted that the fifth acquiring unit 1202, the sixth acquiring unit 1204, the third executing unit 1206 and the third storing unit 1208 correspond to steps S402 to S408 in embodiment 1, and the four units are the same as the examples and application scenarios implemented by the corresponding steps, but are not limited to the disclosure of the first embodiment. It should be noted that the above-described unit may be operated as a part of the apparatus in the computer terminal 10 provided in the first embodiment.

According to an embodiment of the present invention, there is also provided a data processing apparatus for implementing the data processing method shown in fig. 5.

Fig. 13 is a schematic diagram of another data processing apparatus according to an embodiment of the present invention. As shown in fig. 13, the data processing apparatus 1300 may include: a first trigger unit 1302 and a first display unit 1304.

The first triggering unit 1302 is configured to trigger a target request in response to a first operation instruction acting on the operation interface, where the target request is used to request the server to execute the target function.

The first display unit 1304 is configured to display, on the operation interface, a result of a second execution state of the objective function in response to a second operation instruction acting on the operation interface, where the second execution state is obtained by the server obtaining from the object queue and responding to the object request, triggering execution of the objective function based on the first execution state stored in the object storage location, and the first execution state is a latest execution state of the objective function stored in the object storage location in the history period.

Here, it should be noted that the first trigger unit 1302 and the first display unit 1304 correspond to steps S502 to S504 in embodiment 1, and the two units are the same as the examples and application scenarios implemented by the corresponding steps, but are not limited to the disclosure of the first embodiment. It should be noted that the above-described unit may be operated as a part of the apparatus in the computer terminal 10 provided in the first embodiment.

According to an embodiment of the present invention, there is also provided a data processing apparatus for implementing the data processing method shown in fig. 6.

Fig. 14 is a schematic diagram of another data processing apparatus according to an embodiment of the present invention. As shown in fig. 14, the data processing apparatus 1400 may include: a seventh acquisition unit 1402, an eighth acquisition unit 1404, a fourth execution unit 1406, a fourth storage unit 1408, and an output unit 1410.

A seventh obtaining unit 1402, configured to obtain a target request from a target queue by calling a first interface, where the first interface includes a first parameter, a parameter value of the first parameter is the target request, the target queue is used to store the received at least one request, and the target request is used to request to execute a target function.

The eighth obtaining unit 1404 is configured to obtain, in response to the target request, a first execution state at the target storage location, where the first execution state is a latest execution state of the target function stored to the target storage location during the history period.

The fourth execution unit 1406 is configured to trigger the execution of the objective function based on the first execution state, so as to obtain a second execution state of the objective function.

A fourth storage unit 1408 for storing the second execution state to the target storage location.

The output unit 1410 is configured to output a storage result of the second execution state stored in the target storage location by calling a second interface, where the second interface includes a second parameter, and a parameter value of the second parameter is the storage result.

Here, it should be noted that the seventh acquiring unit 1402, the eighth acquiring unit 1404, the fourth executing unit 1406, the fourth storing unit 1408, and the output unit 1410 correspond to steps S602 to S610 in embodiment 1, and the five units are the same as the examples and application scenarios implemented by the corresponding steps, but are not limited to the disclosure of the first embodiment. It should be noted that the above-described unit may be operated as a part of the apparatus in the computer terminal 10 provided in the first embodiment.

In the resource allocation apparatus of this embodiment, a target request is acquired from a target queue by a first acquisition unit, wherein the target queue is used for storing at least one received request, and the target request is used for requesting execution of a target function; responding to the target request through a second acquisition unit, and acquiring execution data output by a target engine; acquiring a first execution state in a target storage position through a first execution unit, wherein the first execution state is the latest execution state of an objective function stored in the target storage position in a history period; triggering the target function to execute based on the first execution state through the first execution unit to obtain a second execution state of the target function; the second execution state is stored to the target storage position through the first storage unit, so that state conversion can not be carried out from beginning to end, state recovery and information can be re-entered, the uniqueness of system task scheduling is guaranteed, the technical effect of improving the reliability of function execution is achieved, and the technical problem of low reliability of function execution is solved.

Example 4

Embodiments of the present invention may provide a data processing system that may include a computer terminal, which may be any one of a group of computer terminals. Alternatively, in the present embodiment, the above-described computer terminal may be replaced with a terminal device such as a mobile terminal.

Alternatively, in this embodiment, the above-mentioned computer terminal may be located in at least one network device among a plurality of network devices of the computer network.

In this embodiment, the above-mentioned computer terminal may execute the program code of the following steps in the resource allocation method of the application program: acquiring a target request, wherein the target request is used for requesting execution of a target function; responding to the target request, and acquiring execution data output by a target engine; acquiring a first execution state associated with execution data at a target storage location, wherein the first execution state is the latest execution state of an objective function stored to the target storage location in a history period; triggering the target function to execute based on the first execution state to obtain a second execution state of the target function; the second execution state is stored to the target storage location.

Alternatively, fig. 15 is a block diagram of a computer terminal according to an embodiment of the present invention. As shown in fig. 15, the computer terminal a may include: one or more (only one is shown) processors 1502, memory 1504, and transmission means 1506.

The memory may be used to store software programs and modules, such as program instructions/modules corresponding to the data processing methods and apparatuses in the embodiments of the present invention, and the processor executes the software programs and modules stored in the memory, thereby executing various functional applications and data processing, that is, implementing the data processing methods described above. The memory may include high-speed random access memory, and may also include non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid-state memory. In some examples, the memory may further include memory remotely located with respect to the processor, which may be connected to terminal a through a network. Examples of such networks include, but are not limited to, the internet, intranets, local area networks, mobile communication networks, and combinations thereof.

The processor may call the information and the application program stored in the memory through the transmission device to perform the following steps: obtaining a target request from a target queue, wherein the target queue is used for storing at least one received request, and the target request is used for requesting execution of a target function; responding to the target request, and acquiring a first execution state in a target storage position, wherein the first execution state is the latest execution state of the target function stored in the target storage position in a history period; triggering the target function to execute based on the first execution state to obtain a second execution state of the target function; the second execution state is stored to the target storage location.

Optionally, the above processor may further execute program code for: obtaining a target request, comprising: and if the target function is determined to interrupt execution, acquiring a target request.

Optionally, the above processor may further execute program code for: determining that the objective function interrupts execution, comprising: and triggering the target function to interrupt execution if the first target device is in the abnormal state, wherein the first target device is used for triggering the target function to execute so as to obtain a first execution state.

Optionally, the above processor may further execute program code for: obtaining a target request, comprising: and monitoring a target request based on the second target device, wherein the model of the second target device is the same as the model of the first target device.

Optionally, the above processor may further execute program code for: before the target request is monitored based on the second target device, the method further comprises: based on the first target device monitoring the target request; responding to the target request, triggering the target function to execute, and obtaining a first execution state; the first execution state is stored to the target storage location.

Optionally, the above processor may further execute program code for: triggering the execution of the objective function to obtain a first execution state, including: and triggering the execution of the target function to obtain a first execution state if the execution state of the target function is not stored in the target storage position.

Optionally, the above processor may further execute program code for: triggering the execution of the objective function based on the first execution state to obtain a second execution state of the objective function, including: determining that the first execution state is a state of the target function which is not executed, determining a first target operation, and triggering the target function to execute the first target operation to obtain a second execution state; and determining the first execution state to represent the state of the executed objective function, and triggering the objective function to execute the second objective operation based on the determined second objective operation to obtain the second execution state.

Optionally, the above processor may further execute program code for: acquiring a first execution state at a target storage location, comprising: a first execution state is retrieved from a target storage location based on a target toolkit associated with the target function.

Optionally, the above processor may further execute program code for: triggering the execution of the objective function based on the first execution state to obtain a second execution state of the objective function, including: triggering the target function to execute based on the first execution state based on the call information to obtain a second execution state.

As an alternative example, the processor may call the information stored in the memory and the application program through the transmission device to perform the following steps: obtaining a target request of the live platform from a target queue, wherein the target queue is used for storing at least one received request, and the target request is used for requesting execution of a target function; responding to the target request, and acquiring a first execution state in a target storage position, wherein the first execution state is the latest execution state of the target function stored in the target storage position in a history period; triggering the target function to execute based on the first execution state to obtain a second execution state of the target function; the second execution state is stored to the target storage location.

As an alternative example, the processor may call the information stored in the memory and the application program through the transmission device to perform the following steps: obtaining a target request of a video playing platform from a target queue, wherein the target queue is used for storing at least one received request, and the target request is used for requesting to execute a target function; responding to the target request, and acquiring a first execution state in a target storage position, wherein the first execution state is the latest execution state of the target function stored in the target storage position in a history period; triggering the target function to execute based on the first execution state to obtain a second execution state of the target function; the second execution state is stored to the target storage location.

As an alternative example, the processor may call the information stored in the memory and the application program through the transmission device to perform the following steps: triggering a target request in response to a first operation instruction acting on an operation interface, wherein the target request is used for requesting a server to execute a target function; and responding to a second operation instruction acting on the operation interface, and displaying a result of a second execution state of the objective function on the operation interface, wherein the second execution state is obtained by the server from the target queue and responding to the target request, the trigger objective function is executed based on a first execution state which is stored in the target storage position and is associated with execution data, and the first execution state is the latest execution state of the objective function stored in the target storage position in a history period.

As an alternative example, the processor may call the information stored in the memory and the application program through the transmission device to perform the following steps: acquiring a target request from a target queue by calling a first interface, wherein the first interface comprises a first parameter, the parameter value of the first parameter is the target request, the target queue is used for storing at least one received request, and the target request is used for requesting execution of a target function; responding to the target request, and acquiring a first execution state in a target storage position, wherein the first execution state is the latest execution state of the target function stored in the target storage position in a history period; triggering the target function to execute based on the first execution state to obtain a second execution state of the target function; storing the second execution state to the target storage location; and outputting a storage result of the second execution state stored to the target storage position by calling a second interface, wherein the second interface comprises a second parameter, and the parameter value of the second parameter is the storage result.

The embodiment of the invention provides a data processing method, which adopts a function calculation stateful asynchronous calling method, and realizes state conversion without from beginning to end, state recovery and message reentry by providing a triggering target function based on the execution of a first execution state, thereby ensuring the uniqueness of system task scheduling, further realizing the technical effect of improving the reliability of function execution and solving the technical problem of low reliability of function execution.

It will be appreciated by those skilled in the art that the structure shown in fig. 15 is only illustrative, and the computer terminal a may be a terminal device such as a smart phone (e.g. an Android phone, an iOS phone, etc.), a tablet computer, a palm computer, a Mobile internet device (Mobile INTERNET DEVICES, MID), a PAD, etc. Fig. 15 does not limit the structure of the computer terminal a. For example, the computer terminal a may also include more or fewer components (such as a network interface, a display device, etc.) than shown in fig. 15, or have a different configuration than shown in fig. 15.

Those of ordinary skill in the art will appreciate that all or part of the steps in the various methods of the above embodiments may be implemented by a program for instructing a terminal device to execute in association with hardware, the program may be stored in a computer readable storage medium, and the storage medium may include: flash disk, read-Only Memory (ROM), random-access Memory (Random Access Memory, RAM), magnetic disk or optical disk, etc.

Example 5

Embodiments of the present invention also provide a computer-readable storage medium. Alternatively, in this embodiment, the computer readable storage medium may be used to store the program code executed by the data processing method provided in the first embodiment.

Alternatively, in this embodiment, the above-mentioned computer-readable storage medium may be located in any one of the computer terminals in the computer terminal group in the computer network, or in any one of the mobile terminals in the mobile terminal group.

Optionally, in the present embodiment, the above-mentioned computer-readable storage medium is configured to store program code for performing the steps of: obtaining a target request from a target queue, wherein the target queue is used for storing at least one received request, and the target request is used for requesting execution of a target function; responding to the target request, and acquiring a first execution state in a target storage position, wherein the first execution state is the latest execution state of the target function stored in the target storage position in a history period; triggering the target function to execute based on the first execution state to obtain a second execution state of the target function; the second execution state is stored to the target storage location.

Optionally, the above computer readable storage medium may further execute program code for: obtaining a target request, comprising: and if the target function is determined to interrupt execution, acquiring a target request.

Optionally, the above computer readable storage medium may further execute program code for: determining that the objective function interrupts execution, comprising: and triggering the target function to interrupt execution if the first target device is in the abnormal state, wherein the first target device is used for triggering the target function to execute so as to obtain a first execution state.

Optionally, the above computer readable storage medium may further execute program code for: obtaining a target request, comprising: and monitoring a target request based on the second target device, wherein the model of the second target device is the same as the model of the first target device.

Optionally, the above computer readable storage medium may further execute program code for: before the target request is monitored based on the second target device, the method further comprises: based on the first target device monitoring the target request; responding to the target request, triggering the target function to execute, and obtaining a first execution state; the first execution state is stored to the target storage location.

Optionally, the above computer readable storage medium may further execute program code for: triggering the execution of the objective function to obtain a first execution state, including: and triggering the execution of the target function to obtain a first execution state if the execution state of the target function is not stored in the target storage position.

Optionally, the above computer readable storage medium may further execute program code for: triggering the execution of the objective function based on the first execution state to obtain a second execution state of the objective function, including: determining that the first execution state is a state of the target function which is not executed, determining a first target operation, and triggering the target function to execute the first target operation to obtain a second execution state; and determining the first execution state to represent the state of the executed objective function, and triggering the objective function to execute the second objective operation based on the determined second objective operation to obtain the second execution state.

Optionally, the above computer readable storage medium may further execute program code for: acquiring a first execution state at a target storage location, comprising: a first execution state is retrieved from a target storage location based on a target toolkit associated with the target function.

Optionally, the above computer readable storage medium may further execute program code for: triggering the execution of the objective function based on the first execution state to obtain a second execution state of the objective function, including: triggering the target function to execute based on the first execution state based on the call information to obtain a second execution state.

As an alternative example, the computer readable storage medium is arranged to store program code for performing the steps of: obtaining a target request of the live platform from a target queue, wherein the target queue is used for storing at least one received request, and the target request is used for requesting execution of a target function; responding to the target request, and acquiring a first execution state in a target storage position, wherein the first execution state is the latest execution state of the target function stored in the target storage position in a history period; triggering the target function to execute based on the first execution state to obtain a second execution state of the target function; the second execution state is stored to the target storage location.

As an alternative example, the computer readable storage medium is arranged to store program code for performing the steps of: obtaining a target request of a video playing platform from a target queue, wherein the target queue is used for storing at least one received request, and the target request is used for requesting to execute a target function; responding to the target request, and acquiring a first execution state in a target storage position, wherein the first execution state is the latest execution state of the target function stored in the target storage position in a history period; triggering the target function to execute based on the first execution state to obtain a second execution state of the target function; the second execution state is stored to the target storage location.

As an alternative example, the computer readable storage medium is arranged to store program code for performing the steps of: triggering a target request in response to a first operation instruction acting on an operation interface, wherein the target request is used for requesting a server to execute a target function; and responding to a second operation instruction acting on the operation interface, and displaying a result of a second execution state of the objective function on the operation interface, wherein the second execution state is obtained by the server from the target queue and responding to the target request, the trigger objective function is executed based on a first execution state which is stored in the target storage position and is associated with execution data, and the first execution state is the latest execution state of the objective function stored in the target storage position in a history period.

As an alternative example, the computer readable storage medium is arranged to store program code for performing the steps of: acquiring a target request from a target queue by calling a first interface, wherein the first interface comprises a first parameter, the parameter value of the first parameter is the target request, the target queue is used for storing at least one received request, and the target request is used for requesting execution of a target function; responding to the target request, and acquiring a first execution state in a target storage position, wherein the first execution state is the latest execution state of the target function stored in the target storage position in a history period; triggering the target function to execute based on the first execution state to obtain a second execution state of the target function; storing the second execution state to the target storage location; and outputting a storage result of the second execution state stored to the target storage position by calling a second interface, wherein the second interface comprises a second parameter, and the parameter value of the second parameter is the storage result.

The foregoing embodiment numbers of the present invention are merely for the purpose of description, and do not represent the advantages or disadvantages of the embodiments.

In the foregoing embodiments of the present invention, the descriptions of the embodiments are emphasized, and for a portion of this disclosure that is not described in detail in this embodiment, reference is made to the related descriptions of other embodiments.

In the several embodiments provided in the present application, it should be understood that the disclosed technology may be implemented in other manners. The above-described embodiments of the apparatus are merely exemplary, and the division of the units, such as the division of the units, is merely a logical function division, and may be implemented in another manner, for example, multiple units or components may be combined or may be integrated into another system, or some features may be omitted, or not performed. Alternatively, the coupling or direct coupling or communication connection shown or discussed with each other may be through some interfaces, units or modules, or may be in electrical or other forms.

The units described as separate units may or may not be physically separate, and units shown 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 may be selected according to actual needs to achieve the purpose of the solution of this embodiment.

In addition, each functional unit in the embodiments of the present invention may be integrated in one processing unit, or each unit may exist alone physically, or two or more units may be integrated in one unit. The integrated units may be implemented in hardware or in software functional units.

The integrated units, if implemented in the form of software functional units and sold or used as stand-alone products, may be stored in a computer readable storage medium. Based on such understanding, the technical solution of the present invention may be embodied essentially or in part or all of the technical solution or in part in the form of a software product stored in a storage medium, including instructions for causing a computer device (which may be a personal computer, a server, or a network device, etc.) to perform all or part of the steps of the method according to the embodiments of the present invention. And the aforementioned storage medium includes: a usb disk, a Read-Only Memory (ROM), a random access Memory (RAM, random Access Memory), a removable hard disk, a magnetic disk, or an optical disk, or other various media capable of storing program codes.

The foregoing is merely a preferred embodiment of the present invention and it should be noted that modifications and adaptations to those skilled in the art may be made without departing from the principles of the present invention, which are intended to be comprehended within the scope of the present invention.

Claims

1. A method of data processing, comprising:

Obtaining a target request from a target queue, wherein the target queue is used for storing at least one received request, and the target request is used for requesting to execute a target function;

Responding to the target request, and acquiring a first execution state in a target storage position, wherein the first execution state is the latest execution state of the target function stored in the target storage position in a history period and is obtained by triggering and executing the target function through a state machine model;

triggering the target function to execute based on the first execution state to obtain a second execution state of the target function;

Storing the second execution state to the target storage location;

Wherein obtaining the first execution state at the target storage location includes: and acquiring the first execution state from the target storage location based on a target tool package associated with the target function, wherein the target tool package is used for synchronously adding the latest execution state to the target storage location when the latest execution state is obtained by the execution of the target function.

2. The method of claim 1, wherein obtaining the target request comprises:

and if the target function is determined to interrupt execution, acquiring the target request.

3. The method of claim 2, wherein determining that the objective function interrupts execution comprises:

and triggering the target function to interrupt execution if the first target equipment is in the abnormal state, wherein the first target equipment is used for triggering the target function to execute so as to obtain the first execution state.

4. A method according to claim 3, wherein obtaining the target request comprises:

and monitoring the target request based on a second target device, wherein the model of the second target device is the same as the model of the first target device.

5. The method of claim 4, wherein prior to listening for the target request based on the second target device, the method further comprises:

Based on the first target device listening for the target request;

Responding to the target request, triggering the target function to execute, and obtaining the first execution state;

And storing the first execution state to the target storage position.

6. The method of claim 5, wherein triggering the execution of the objective function to obtain the first execution state comprises:

and triggering the target function to execute if the execution state of the target function is not stored in the target storage position, so as to obtain the first execution state.

7. The method of claim 1, wherein triggering execution of the objective function based on the first execution state results in a second execution state of the objective function, comprising:

determining a first target operation if the first execution state is the state that the target function is not executed, and triggering the target function to execute the first target operation to obtain the second execution state;

and determining that the first execution state is used for representing the executed state of the objective function, determining a second objective operation based on the executed state, and triggering the objective function to execute the second objective operation to obtain the second execution state.

8. The method according to any one of claims 1 to 7, wherein,

Triggering the target function to execute based on the first execution state to obtain a second execution state of the target function, wherein the second execution state comprises: and triggering the target function to execute based on the first execution state based on the calling information to obtain the second execution state.

9. A method of data processing, comprising:

Obtaining a target request of a live platform from a target queue, wherein the target queue is used for storing at least one received request, and the target request is used for requesting execution of a target function;

Responding to the target request, and acquiring a first execution state in a target storage position, wherein the first execution state is the latest execution state of the target function stored in the target storage position in a history period;

Storing the second execution state to the target storage location;

10. A method of data processing, comprising:

Obtaining a target request of a video playing platform from a target queue, wherein the target queue is used for storing at least one received request, and the target request is used for requesting to execute a target function;

Storing the second execution state to the target storage location;

11. A method of data processing, comprising:

Triggering a target request in response to a first operation instruction acting on an operation interface, wherein the target request is used for requesting a server to execute a target function;

Responding to a second operation instruction acting on the operation interface, and displaying a result of a second execution state of the objective function on the operation interface, wherein the second execution state is obtained by the server from a target queue and responding to the target request, the execution of the objective function based on a first execution state stored in a target storage position is triggered, and the first execution state is the latest execution state of the objective function stored in the target storage position in a history period and is obtained by triggering the execution of the objective function through a state machine model;

the first execution state is obtained from the target storage location based on a target tool package associated with the target function, and the target tool package is used for synchronously adding the latest execution state to the target storage location when the latest execution state is obtained by executing the target function.

12. A method of data processing, comprising:

acquiring a target request from a target queue by calling a first interface, wherein the first interface comprises a first parameter, the parameter value of the first parameter is the target request, the target queue is used for storing at least one received request, and the target request is used for requesting to execute a target function;

Storing the second execution state to the target storage location;

Outputting a storage result of the second execution state stored to the target storage position by calling a second interface, wherein the second interface comprises a second parameter, and the parameter value of the second parameter is the storage result;