CN117193744A - Method and device for arranging application delivery flow based on rule expression - Google Patents

Abstract

The invention provides a method and a device for arranging application delivery flow based on a rule expression. The method comprises the following steps: step 1: the release of the application is divided into four stages of cloning, compiling, packaging and release, and a component for completing the target function of each stage is developed for each stage; step 2: providing a canvas function for a user to drag the corresponding components into the canvas according to the need, and connecting each component according to the execution direction of the application delivery flow task after the dragging is completed so as to generate a directed acyclic graph; step 3: analyzing the directed acyclic graph into a rule expression, and continuously storing the rule expression; step 4: and loading the persistent rule expression and performing inverse analysis to generate an ordered node set List of the application delivery flow task, traversing the set List, and executing the task represented by the node in the traversing process.

Description

Method and device for arranging application delivery flow based on rule expression

Technical Field

The invention relates to the technical field of application delivery and agile development, in particular to a method and a device for arranging an application delivery flow based on a rule expression.

Background

With the rapid development of information technology, applications play an increasingly important role in people's life. The continuous emergence of the fields of mobile applications, web applications, cloud services, internet of things and the like makes development and delivery of application programs more challenging.

Under the traditional development and delivery modes, the development of the application program is often an independent and linear process, and a development team needs to go through multiple links such as demand analysis, design, coding, testing and deployment, which may lead to long development cycle and delivery delay, and is difficult to rapidly meet market demands. Meanwhile, in the conventional development and delivery modes, the progress of each link is affected by other links due to the serial processing of each stage, resulting in lower overall efficiency. For example, understanding inaccuracies may occur in the demand collection link, resulting in errors in subsequent designs and encodings; serious bugs may be found in the test link, requiring rework and repair. Both of these problems lead to extended lead times and unstable lead quality. Moreover, because the development process lacks automation, a large amount of manpower and material resources are required to be input, and the development cost is increased.

However, as market competition increases, users' demands for application quality and response speed continue to increase. Traditional development and delivery modes are not able to meet the need for rapid delivery of high quality applications. Thus, there is a need for a more efficient, rapid, and stable method and apparatus to address these challenges.

Disclosure of Invention

In order to meet the requirements of users for rapidly delivering high-quality applications, the invention provides a method and a device for arranging application delivery flows based on rule expressions.

In a first aspect, the present invention provides a method for orchestrating application delivery flows based on regular expressions, comprising:

step 1: the release of the application is divided into four stages of cloning, compiling, packaging and release, and a component for completing the target function of each stage is developed for each stage;

step 2: providing a canvas function for a user to drag the corresponding components into the canvas according to the need, and connecting each component according to the execution direction of the application delivery flow task after the dragging is completed so as to generate a directed acyclic graph;

step 3: analyzing the directed acyclic graph into a rule expression, and continuously storing the rule expression;

step 4: and loading the persistent rule expression and performing inverse analysis to generate an ordered node set List of the application delivery flow task, traversing the set List, and executing the task represented by the node in the traversing process.

Further, the step 1 specifically includes:

a clone component for the clone phase, a code specification component and security detection component for the compile phase, a packaging component for the packaging phase, and a release component for the release phase are developed.

Further, step 2 specifically further includes: dividing the whole canvas area into a cloning area, a compiling area, a packing area and a publishing area, and setting constraint conditions of the canvas;

the constraint conditions include: the cloning assembly can only be dragged to the cloning region; the compilation component can only be dragged to the compilation region; the packing assembly can only be dragged to the packing area; the publishing component can only be dragged to the publishing area; the same component in the same area cannot be repeatedly dragged; different components of the same area can be repeatedly dragged.

Further, the step 3 specifically includes:

each node in the directed acyclic graph is taken as one node in the rule expression, T is adopted to represent the rule expression of the serial task formed by each node, W is adopted to represent the rule expression of the parallel task formed by each node, and one directed acyclic graph has and corresponds to only one rule expression.

Further, step 4 specifically includes:

defining a rule expression W to represent a virtual node, wherein nodes inside the rule expression W and nodes outside the rule expression W represent actual nodes;

traversing the rule expression, and when encountering the rule expression T, creating a List, and adding nodes in the T into the List;

in the traversal process, when an actual node is encountered, a NodeR is created and added into a List; when encountering a virtual node, creating a NodeV, adding the NodeV into a List, and adding nodes in the false node into an unordered Set;

after the List generation of the Set is completed, traversing the List Set, executing tasks represented by corresponding nodes when NodeR is encountered, traversing the Set when NodeV is encountered, and concurrently executing tasks represented by all nodes in the Set until the traversing is completed to finally complete all nodes in the List.

In a second aspect, the present invention provides an apparatus for scheduling application delivery flows based on a rule expression, comprising:

the component development engine is used for dividing the release of the application into four stages of cloning, compiling, packaging and release, and developing a component for completing the target function of each stage for each stage;

the rule design engine is used for providing a canvas function for a user to drag the corresponding components into the canvas according to the need, and connecting each component according to the execution direction of the application delivery flow task after the dragging is completed so as to generate a directed acyclic graph;

the rule analyzer is used for analyzing the directed acyclic graph into a rule expression and continuously storing the rule expression;

the rule execution engine is used for loading the lasting rule expression and performing inverse analysis to generate an ordered node set List of the application delivery flow task, traversing the set List, and executing the task represented by the node in the traversing process.

Further, the rule parser is specifically configured to use each node in the directed acyclic graph as one node in the rule expressions, denote the rule expressions of the serial tasks composed of the nodes by using T, denote the rule expressions of the parallel tasks composed of the nodes by using W, and one directed acyclic graph has and corresponds to only one rule expression.

Further, the rule execution engine is specifically configured to define that the rule expression W itself represents a virtual node, and both the node inside the rule expression W and the node outside the rule expression W represent actual nodes; traversing the rule expression, and when encountering the rule expression T, creating a List, and adding nodes in the T into the List; in the traversal process, when an actual node is encountered, a NodeR is created and added into a List; when encountering a virtual node, creating a NodeV, adding the NodeV into a List, and adding nodes in the false node into an unordered Set; after the List generation of the Set is completed, traversing the List Set, executing tasks represented by corresponding nodes when NodeR is encountered, traversing the Set when NodeV is encountered, and concurrently executing tasks represented by all nodes in the Set until the traversing is completed to finally complete all nodes in the List.

In a third aspect, the present invention provides an electronic device comprising: the device comprises a memory and a processor, wherein the processor and the memory are communicated with each other through a bus; the memory stores program instructions executable by the processor that invoke the method of scheduling application delivery flows based on the regular expressions, any of which are described above.

In a fourth aspect, the present invention provides a computer readable storage medium having stored thereon a computer program which when executed by a processor implements any of the methods of scheduling application delivery flows based on a regular expression described above.

The invention has the beneficial effects that:

(1) And (3) quick delivery: the adoption of the regular expression architecture and the automation tool greatly shortens the delivery cycle of the application. From demand determination to final delivery, time is greatly compressed, enabling applications to respond to market demand more quickly.

(2) High efficiency: the use of parallel processing and automation tools reduces unnecessary waiting time and improves overall delivery efficiency. Developers and test teams can be more focused on core tasks and are no longer hindered by cumbersome manual work.

(3) The cost is reduced: the automatic flow and containerization technology reduces the resource consumption in the development and delivery process and reduces the development cost. At the same time, rapid delivery also helps businesses to withdraw investment faster and achieve commercial value quickly.

(4) Regularization of task flow: by standardizing the application delivery flow into four phases and then using a rule engine to express, the flow is creatively templated, so that the execution of subsequent tasks is facilitated;

(5) Dynamically parsing the rule expression: the application delivery DAG graph is analyzed into the EL expression through the rule analyzer, so that the EL expression is more convenient to store, occupies smaller space, can be rapidly reversely analyzed, and is convenient to apply and deliver faster;

(6) By introducing the concept of virtual nodes, the EL expression is analyzed into an ordered set of the actual nodes and the virtual nodes, and the method is simple and clear, so that the efficiency in the process of executing the node task is greatly improved, and the delivery cycle of the application is accelerated.

Drawings

FIG. 1 is a flow diagram of a method for scheduling application delivery flows based on rule expressions according to an embodiment of the present invention;

FIG. 2 is a schematic diagram of the generation of a directed acyclic graph provided by an embodiment of the present invention;

FIGS. 3, 4 and 5 are examples of directed acyclic graphs of three application delivery flows provided by embodiments of the present invention, respectively;

FIG. 6 is a schematic structural diagram of an apparatus for scheduling application delivery flows based on rule expressions according to an embodiment of the present invention;

fig. 7 is a block diagram of an electronic device according to an embodiment of the present invention.

Detailed Description

For the purpose of making the objects, technical solutions and advantages of the present invention more apparent, the technical solutions in the embodiments of the present invention will be clearly described below with reference to the accompanying drawings in the embodiments of the present invention, and it is apparent that the described embodiments are some embodiments of the present invention, but not all embodiments. All other embodiments, which can be made by those skilled in the art based on the embodiments of the invention without making any inventive effort, are intended to be within the scope of the invention.

Example 1

As shown in fig. 1, an embodiment of the present invention provides a method for arranging an application delivery flow based on a rule expression, including the following steps:

s101: the release of the application is divided into four stages of cloning, compiling, packaging and release, and a component for completing the target function of each stage is developed for each stage;

specifically, cloning stage: the development team detects the code of the application from the source code version control system. This stage involves retrieving the latest version of code from the code repository and ensuring that all modifications have been synchronized to the local work environment. The key objective of the cloning stage is to obtain the latest code for the subsequent compilation and construction process. The cloning stage develops a component of the overhead clone code, simply called the cloning component, such as the git component, which is the code that is retrieved from a repository that supports the git protocol. The svn component is a repository that retrieves code from a repository that supports the svn protocol.

Compiling: the source code of the application is compiled into executable binary code or bytecode. The compilation process converts source code into a set of instructions that can be understood and executed by a computer, which is the basis for deploying an application to a target platform. At this stage, the development team will check if the compilation was successful, if there is a compilation error or warning. The compiling stage mainly checks the format, specification and safety of the code, so that components such as code specification components, safety detection components and the like need to be developed.

Packaging: the compiled executable code and associated resources are packaged into a separate, distributable application package. This application package is typically an installation package or container that contains all the necessary files and dependencies of the application. The packaging process may also involve optimizing the application to ensure that it runs efficiently in the target environment. The packing stage mainly packs codes, so that a packing component needs to be developed, the packing component comprises a physical package and a container package, the physical package is supported according to each language characteristic, for example, a java program packages a jar package, and c++ packages an exe. The container package is then a container program, such as a dock mirror. There is therefore a need to develop container assemblies and physical package assemblies.

The release stage: and deploying the packaged application program package into a target environment for use by an end user. This stage involves deploying the application onto a server, cloud platform, mobile device, or other target platform. The release process may further include configuration and initialization of the application program to ensure that the application program can run smoothly and provide services to the outside. And the release stage releases the product of the packaging stage. A publishing component needs to be developed. Such as a k8s component that supports publishing container packages to k8s clusters, or an ECS component that supports publishing physical packages to ECS clusters.

S102: providing a canvas function for a user to drag the corresponding components into the canvas according to the need, and connecting each component according to the execution direction of the application delivery flow task after the dragging is completed so as to generate a directed acyclic graph; as shown in fig. 2.

Specifically, in order to facilitate subsequent generation of the directed acyclic graph, in this embodiment, the entire canvas area is divided into a cloning area, a compiling area, a packaging area and a publishing area from front to back, and constraint conditions of the canvas are set; the constraint conditions include: the cloning assembly can only be dragged to the cloning region; the compilation component can only be dragged to the compilation region; the packing assembly can only be dragged to the packing area; the publishing component can only be dragged to the publishing area; the same component in the same area cannot be repeatedly dragged; different components of the same area can be repeatedly dragged.

S103: analyzing the directed acyclic graph into a rule expression, and continuously storing the rule expression;

specifically, each node in the directed acyclic graph is taken as one node in the rule expression, T is adopted to represent the rule expression of the serial task formed by each node, W is adopted to represent the rule expression of the parallel task formed by each node, and one directed acyclic graph has and corresponds to only one rule expression.

As shown in fig. 3, A, B, C, D respectively represent node components, and the application delivery flow is represented as executing a, then executing B, then executing C, and finally executing D. The serial task is denoted by T, so the EL expression of the above flow is T (a, B, C, D).

As shown in fig. 4, A, B, C, D, E respectively represent node components, and the application delivery flow is represented as executing a first, executing B, C in parallel, executing D, and finally executing E. Since the parallel task is denoted by W, the above flow is resolved into T (a, W (B, C), D).

As shown in fig. 5, A, B, C, D, E represents node components, respectively, and the application delivery flow is represented as first executing a, B and C, D in parallel, wherein C, D is executed serially and finally executing E. Thus, the above procedure is resolved into T (A, W (B, T (C, D)), E).

As can be seen from the above examples of three application delivery flows, the delivery flows only contain parallel and serial based on the characteristics of the application delivery flows, so it is sufficient to support all application delivery flows with T and W.

The generated rule expressions are persisted to a file or database for subsequent loading.

S104: and loading the persistent rule expression and performing inverse analysis to generate an ordered node set List of the application delivery flow task, traversing the set List, and executing the task represented by the node in the traversing process. List represents an ordered set, ordered according to the order in which nodes are added to the set.

Specifically, defining a rule expression W itself to represent a virtual node, where nodes inside the rule expression W and nodes outside the rule expression W both represent actual nodes;

traversing the rule expression, and when encountering the rule expression T, creating a List, and adding nodes in the T into the List;

in the traversal process, when an actual node is encountered, a NodeR is created and added into a List; when encountering a virtual node, creating a NodeV, adding the NodeV into a List, and adding nodes in the false node into an unordered Set;

after the List generation of the Set is completed, traversing the List Set, executing tasks represented by corresponding nodes when NodeR is encountered, traversing the Set when NodeV is encountered, and concurrently executing tasks represented by all nodes in the Set until the traversing is completed to finally complete all nodes in the List.

As an embodiment, the data structure defining the executing task node is as follows:

NodeR{

String name;

List<NodeR>nodes;

}

NodeR represents the actual node, name represents the node name, and List represents an ordered set.

NodeV{

String name;

Set<NodeR>nodes;

}

NodeV represents a virtual node, name represents a node name combination, and Set represents an unordered Set.

As one implementation, the pseudocode that generates the set List is as follows:

initializing task executing node set List

Traversing EL

if (actual node)

Creating an actual node NodeR and adding the actual node NodeR into an execution task node set List

if (virtual node)

Creating a virtual node NodeV

Traversing virtual node interiors

Creating an actual node NodeR and adding the actual node NodeR into an internal unordered Set of a virtual node NodeV

The virtual node NodeV is added into an execution task node set List

And obtaining a final set List.

For example, taking EL expression T (a, W (B, T (C, D)), E) as an example, the set List corresponding to the rule expression = [ nodeb { a, null }, nodeb { b_c_d, [ nodeb { B, null }, nodeb { c_d, [ nodeb { C, null }, nodeb { D, null } ] ], nodeb r { E, null } ].

As one implementation, after completion of the collection List generation, the pseudocode that traverses the List collection is as follows:

traversing List

if (actual node)

Executing node tasks

if (virtual node)

Traversing Set

Concurrent execution of node tasks

And executing the node task according to the flow, and finally completing the release of the application.

The method for arranging the application delivery flow based on the rule expression fully references the ideas of the rule expression and the DAG flow, divides the application delivery process into a plurality of independent links, and realizes quick, efficient and low-cost application delivery through an automation tool and parallel processing.

Example 2

As shown in fig. 6, an embodiment of the present invention provides an apparatus for arranging an application delivery flow based on a rule expression, including: a component development engine, a rule design engine, a rule parser, and a rule execution engine;

the component development engine is used for dividing the release of the application into four stages of cloning, compiling, packaging and release, and developing a component for completing the target function of each stage aiming at each stage; the rule design engine is used for providing a canvas function for a user to drag the corresponding components into the canvas according to the need, and connecting each component according to the execution direction of the application delivery flow task after the dragging is completed so as to generate a directed acyclic graph; the rule analyzer is used for analyzing the directed acyclic graph into a rule expression and continuously storing the rule expression; the rule execution engine is used for loading the lasting rule expression and performing inverse analysis to generate an ordered node set List of the application delivery flow task, traversing the set List, and executing the task represented by the node in the traversing process.

Specifically, first, putting a node assembly on a shelf through an assembly development engine, wherein the node assembly represents a specific task; the canvas is provided by the rule design engine, so that a user drags the components provided by the component development engine into the canvas to realize the design work of the application delivery flow and generate the application delivery execution task DAG model; analyzing the DAG model into an EL expression through a rule analyzer, and storing an application delivery flow model in a lasting mode, so that the method is convenient for multiple times of execution; and (3) reversely analyzing the rule expression by the rule execution engine to generate an execution task node set, and sequentially executing node tasks.

As an implementation manner, the rule parser is specifically configured to use each node in the directed acyclic graph as one node in the rule expressions, denote the rule expressions of the serial tasks composed of the nodes by using T, denote the rule expressions of the parallel tasks composed of the nodes by using W, and one directed acyclic graph has and corresponds to only one rule expression.

As an implementation manner, the rule execution engine is specifically configured to define that the rule expression W itself represents a virtual node, and the node inside the rule expression W and the node outside the rule expression W represent actual nodes; traversing the rule expression, and when encountering the rule expression T, creating a List, and adding nodes in the T into the List; in the traversal process, when an actual node is encountered, a NodeR is created and added into a List; when encountering a virtual node, creating a NodeV, adding the NodeV into a List, and adding nodes in the false node into an unordered Set; after the List generation of the Set is completed, traversing the List Set, executing tasks represented by corresponding nodes when NodeR is encountered, traversing the Set when NodeV is encountered, and concurrently executing tasks represented by all nodes in the Set until the traversing is completed to finally complete all nodes in the List.

It should be noted that, the device for arranging the application delivery flow based on the rule expression provided in the embodiment of the present invention is for implementing the above method, and the function of the device may refer to the above method embodiment specifically and not be described herein.

As shown in fig. 7, an embodiment of the present invention further provides an electronic device, including: a processor 701 and a memory 702, the processor 701 and the memory 702 completing communication with each other through a bus 703; the memory 702 stores program instructions executable by the processor, and the processor 701 invokes the program instructions to perform a method comprising, for example: the release of the application is divided into four stages of cloning, compiling, packaging and release, and a component for completing the target function of each stage is developed for each stage; providing a canvas function for a user to drag the corresponding components into the canvas according to the need, and connecting each component according to the execution direction of the application delivery flow task after the dragging is completed so as to generate a directed acyclic graph; analyzing the directed acyclic graph into a rule expression, and continuously storing the rule expression; and loading the persistent rule expression and performing inverse analysis to generate an ordered node set List of the application delivery flow task, traversing the set List, and executing the task represented by the node in the traversing process.

Embodiments of the present invention also provide a computer program product comprising a computer program stored on a non-transitory computer readable storage medium, the computer program comprising program instructions which, when executed by a computer, are capable of performing the methods provided by the above-described method embodiments, for example comprising: the release of the application is divided into four stages of cloning, compiling, packaging and release, and a component for completing the target function of each stage is developed for each stage; providing a canvas function for a user to drag the corresponding components into the canvas according to the need, and connecting each component according to the execution direction of the application delivery flow task after the dragging is completed so as to generate a directed acyclic graph; analyzing the directed acyclic graph into a rule expression, and continuously storing the rule expression; and loading the persistent rule expression and performing inverse analysis to generate an ordered node set List of the application delivery flow task, traversing the set List, and executing the task represented by the node in the traversing process.

Embodiments of the present invention also provide a computer readable storage medium storing computer instructions that cause a computer to perform the methods provided by the above-described method embodiments, for example, including: the release of the application is divided into four stages of cloning, compiling, packaging and release, and a component for completing the target function of each stage is developed for each stage; providing a canvas function for a user to drag the corresponding components into the canvas according to the need, and connecting each component according to the execution direction of the application delivery flow task after the dragging is completed so as to generate a directed acyclic graph; analyzing the directed acyclic graph into a rule expression, and continuously storing the rule expression; and loading the persistent rule expression and performing inverse analysis to generate an ordered node set List of the application delivery flow task, traversing the set List, and executing the task represented by the node in the traversing process.

Finally, it should be noted that: the above embodiments are only for illustrating the technical solution of the present invention, and are not limiting; although the invention has been described in detail with reference to the foregoing embodiments, it will be understood by those of ordinary skill in the art that: the technical scheme described in the foregoing embodiments can be modified or some technical features thereof can be replaced by equivalents; such modifications and substitutions do not depart from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims (10)

1. A method for orchestrating application delivery flows based on regular expressions, comprising:

step 1: the release of the application is divided into four stages of cloning, compiling, packaging and release, and a component for completing the target function of each stage is developed for each stage;

step 2: providing a canvas function for a user to drag the corresponding components into the canvas according to the need, and connecting each component according to the execution direction of the application delivery flow task after the dragging is completed so as to generate a directed acyclic graph;

step 3: analyzing the directed acyclic graph into a rule expression, and continuously storing the rule expression;

step 4: and loading the persistent rule expression and performing inverse analysis to generate an ordered node set List of the application delivery flow task, traversing the set List, and executing the task represented by the node in the traversing process.

2. The method for orchestrating application delivery flows based on regular expressions according to claim 1, wherein step 1 specifically comprises:

a clone component for the clone phase, a code specification component and security detection component for the compile phase, a packaging component for the packaging phase, and a release component for the release phase are developed.

3. The method for orchestrating application delivery flows based on regular expressions according to claim 2, wherein step 2 specifically further comprises: dividing the whole canvas area into a cloning area, a compiling area, a packing area and a publishing area, and setting constraint conditions of the canvas;

the constraint conditions include: the cloning assembly can only be dragged to the cloning region; the compilation component can only be dragged to the compilation region; the packing assembly can only be dragged to the packing area; the publishing component can only be dragged to the publishing area; the same component in the same area cannot be repeatedly dragged; different components of the same area can be repeatedly dragged.

4. The method for orchestrating application delivery flows based on regular expressions according to claim 1, wherein step 3 specifically comprises:

each node in the directed acyclic graph is taken as one node in the rule expression, T is adopted to represent the rule expression of the serial task formed by each node, W is adopted to represent the rule expression of the parallel task formed by each node, and one directed acyclic graph has and corresponds to only one rule expression.

5. The method for orchestrating application delivery flows based on regular expressions according to claim 4, wherein step 4 specifically comprises:

defining a rule expression W to represent a virtual node, wherein nodes inside the rule expression W and nodes outside the rule expression W represent actual nodes;

traversing the rule expression, and when encountering the rule expression T, creating a List, and adding nodes in the T into the List;

in the traversal process, when an actual node is encountered, a NodeR is created and added into a List; when encountering a virtual node, creating a NodeV, adding the NodeV into a List, and adding nodes in the false node into an unordered Set;

after the List generation of the Set is completed, traversing the List Set, executing tasks represented by corresponding nodes when NodeR is encountered, traversing the Set when NodeV is encountered, and concurrently executing tasks represented by all nodes in the Set until the traversing is completed to finally complete all nodes in the List.

6. An apparatus for orchestrating application delivery flows based on regular expressions, comprising:

the component development engine is used for dividing the release of the application into four stages of cloning, compiling, packaging and release, and developing a component for completing the target function of each stage for each stage;

the rule design engine is used for providing a canvas function for a user to drag the corresponding components into the canvas according to the need, and connecting each component according to the execution direction of the application delivery flow task after the dragging is completed so as to generate a directed acyclic graph;

the rule analyzer is used for analyzing the directed acyclic graph into a rule expression and continuously storing the rule expression;

the rule execution engine is used for loading the lasting rule expression and performing inverse analysis to generate an ordered node set List of the application delivery flow task, traversing the set List, and executing the task represented by the node in the traversing process.

7. The apparatus for orchestrating application delivery flows based on regular expressions according to claim 6, wherein the rule parser is specifically configured to use each node in the directed acyclic graph as one node in the regular expressions, wherein T represents the regular expressions of the serial tasks composed of the nodes, and W represents the regular expressions of the parallel tasks composed of the nodes, and wherein one directed acyclic graph has and corresponds to only one regular expression.

8. The apparatus for orchestrating application delivery flows based on regular expressions according to claim 7, wherein the rule execution engine is specifically configured to define that the regular expression W itself represents a virtual node, and that nodes inside and outside the regular expression W each represent an actual node; traversing the rule expression, and when encountering the rule expression T, creating a List, and adding nodes in the T into the List; in the traversal process, when an actual node is encountered, a NodeR is created and added into a List; when encountering a virtual node, creating a NodeV, adding the NodeV into a List, and adding nodes in the false node into an unordered Set; after the List generation of the Set is completed, traversing the List Set, executing tasks represented by corresponding nodes when NodeR is encountered, traversing the Set when NodeV is encountered, and concurrently executing tasks represented by all nodes in the Set until the traversing is completed to finally complete all nodes in the List.

9. An electronic device, comprising: the device comprises a memory and a processor, wherein the processor and the memory are communicated with each other through a bus; the memory stores program instructions executable by the processor, the processor invoking the program instructions to perform the method of any of claims 1-5.

10. A computer readable storage medium, on which a computer program is stored, characterized in that the computer program, when being executed by a processor, implements the method according to any one of claims 1 to 5.