CN1728165A - Multitask coordinated dispatching method in use for workflow engine - Google Patents

Abstract

A method for coordination - dispatching multitask used in operation stream engine includes structuring multistep task coordination net with four element set of N= ( C, T : W , D ) , initializing all operations before multitask is dispatched, dispatching start - up case first then dispatching the others as per flow direction of said net and finally dispatching end case automatically according to operation state. The said dispatch includes eight manners of start - up, end, signed and returned task of client computer, multistep task process and reprocess as well as start - up and end circulation.

Description

Multitask cooperative scheduling method for workflow engine

Technical Field

The invention relates to a workflow and business process analysis and modeling technology, in particular to a multitask cooperative scheduling method for a workflow engine.

Prior Art

The main objective of the workflow engine is to implement the scheduling and execution of multiple tasks in the workflow, and the performance of the workflow engine mainly depends on the scheduling method of multiple tasks, so the scheduling method of multiple tasks in the workflow engine is increasingly regarded by academia and industry. The Petri network technology is one of the most commonly used methods in workflow engine multitask scheduling, and a workflow network (WF-net) scheduling method proposed by Van der Aalst on the Petri network basis is the most famous. Knowledge about Petri nets and workflow nets can be referred to in the book "workflow management-model, method and System" (Wilvan der Aalst & Kees vanHee, ed. King of Miner, Renship, etc., Qinghua university Press, 2.2004, ISBN 7-302-.

Although the Petri network-based workflow network technology achieves certain results in the application of workflow engine multitask scheduling, the following problems exist:

1. the workflow network is based on a Petri network formed by triples (P, T; F), conditions are represented by a library (P), tasks are represented by transitions (T), and the conditions and the transitions are connected by flow relations (F). This method is suitable for scheduling situations where each task is only handled by one client (i.e. each task is completed on one client at a time), whereas for situations where a task is handled by multiple clients simultaneously (i.e. each task is completed in stages on multiple clients), the scheduling method fails to achieve normal scheduling because it fails to express the cooperative relationship between multiple clients and multiple tasks.

2. In multi-task scheduling of workflows, reverse scheduling situations often occur where an executed task is rolled back or re-executed. In a Petri network-based workflow network, a library (P) represents a condition, a transition (T) represents a task, and the task can be scheduled only in a forward direction but not in a reverse direction. Therefore, this scheduling method is less practical.

Disclosure of Invention

The invention aims to realize the cooperation between the multi-step tasks and the multiple clients and realize the forward and reverse scheduling of the multi-step tasks, and has strong practicability and flexible scheduling.

The technical scheme of the invention is realized as follows:

1. a multitask cooperative scheduling method for a workflow engine is characterized by comprising the following steps: the method comprises the following steps:

(1) constructing a computing model of a multi-task cooperative method, namely a multi-step task cooperative network, wherein a four-tuple N ═ C, T; W, D) is constructed according to the following sufficient requirements:

1°C≠φ

2°T≠φ

3°CI T＝φ

4°W*C×T

5°D*T×C

6°dom(W)Ycod(W)＝CY T

wherein, <math> <mrow> <mi>dom</mi> <mrow> <mo>(</mo> <mi>W</mi> <mo>)</mo> </mrow> <mo>=</mo> <mo>{</mo> <mi>x</mi> <mo>|</mo> <mo>&Exists;</mo> <mi>y</mi> <mo>:</mo> <mrow> <mo>(</mo> <mi>x</mi> <mo>,</mo> <mi>y</mi> <mo>)</mo> </mrow> <mo>&Element;</mo> <mi>W</mi> <mo>}</mo> <mo>,</mo> <mi>cod</mi> <mrow> <mo>(</mo> <mi>W</mi> <mo>)</mo> </mrow> <mo>=</mo> <mo>{</mo> <mi>y</mi> <mo>|</mo> <mo>&Exists;</mo> <mi>x</mi> <mo>:</mo> <mrow> <mo>(</mo> <mi>x</mi> <mo>,</mo> <mi>y</mi> <mo>)</mo> </mrow> <mo>&Element;</mo> <mi>W</mi> <mo>}</mo> <mo>:</mo> </mrow> </math>

in a quad, C is a limited set of clients; t is a limited set of tasks; w is a collection of jobs representing the division of work by the client in a task; d is a forwarding set, representing the direction of flow of the task.

(2) Constructing a dynamic structure of the multi-step task cooperative network, namely a multi-step task cooperative network system, wherein an octave sigma ═ (C, T; W, D; W0, PD, G, L) is constructed according to the following conditions:

1 DEG N ═ C, T; W, D) is a multi-step mission collaborative network.

2°W₀W is the set of initial jobs. Initiating work refers to work that can be handled without relying on any task client.

3°P_DIs the set of forwarding conditions defined on D. The forwarding condition refers to a condition on which forwarding depends.

4 ° G is a set of packets defined on C. If there is a dependency between the work that the client is about to handle and the tasks that have been completed, the work and the forwarding that delivers the tasks need to be divided into a set, called a packet.

5 L.su.W.su.D, is a cyclic set. A loop refers to a circular path that can be executed repeatedly and only the last execution information is retained.

(3) And constructing state sets required by multitask scheduling, wherein the state sets comprise five state sets:

state set for 1 ° case: si ═ Si_r，Si_w，Sw_f}. The case is one-time execution of the multi-step task collaborative network, and one multi-step task collaborative network can be executed for multiple times, wherein each execution corresponds to a different case. Wherein,

Si_rready state: the case waits for the status of execution,

Si_win the office state: the state in which the case is executing,

Si_fand (4) completion state: state where the case has ended.

Set of states for 2 ° operation: sw ═ { Sw_r，Sw_w，Sw_n，Sw_f}. Wherein,

Sw_rready state: a state in which the job waits for the client to handle,

Sw_win the office state: the state in which work is being transacted by the client,

Sw_nnegative state: the work can not be handled by the client because the condition is not satisfied,

Sw_fand (4) completion state: a state in which the work has ended.

State set of 3 ° service: st ═ St_r，St_w，St_n，St_f}. Wherein,

St_rready state: the task waits for the status of the client to transact,

St_win the office state: the state in which the task is being handled by the client,

St_nnegative state: the task is in a state of being unable to be handled by the client because the condition is not satisfied,

St_fand (4) completion state: a state in which the task has ended.

4 ° forwarded state set: sd ═ Sd_r，Sd_w，Sd_n，Sd_f}. Wherein,

Sd_rready state: forwarding the state waiting to be performed,

Sd_wa state to be signed: forwarding the state waiting to be signed in by the client,

Sd_nnegative state: forwarding a state that cannot be signed by the client because the condition is not satisfied,

Sd_fand (4) completion state: the forwarding has ended.

Set of states for a 5 ° cycle: sl ═ Sl { Sl_r，Sl_w，Sd_f}. Wherein,

Sl_rready state: wait cyclicallyThe state of being executed is such that,

Sl_wthe working state is as follows: the state in which the loop is being executed,

Sl_fand (4) completion state: a state in which the loop has ended.

(4) The multi-task scheduling comprises eight scheduling methods, namely a start case, a stop case, a client sign-on task, a client return task, multi-step task handling, multi-step task reprocessing, a start cycle and a stop cycle. Prior to multitasking, cases and all work, tasks, forwarding, loops are initialized to the ready state. The starting case is the first executed scheduling, the client signs up the task, the client returns the task, the multi-step task is processed, the multi-step task is re-processed, the starting cycle and the terminating cycle are scheduled by the client according to the flow direction of the multi-step task collaborative network, including the forward direction and the reverse direction, and the scheduling of the terminating case is automatically scheduled by the system according to the working and forwarding states.

Order:

setstatus (x) indicates the state of a setting object x, x being a case, task, job, forward, or loop;

GetStatus (x) represents the state of an object x, wherein x is a case, a task, work, forwarding or circulation;

setclient (x) represents the client to which the set object belongs, and x is work or forwarding;

GetClient (x) represents the client to which the obtained object belongs, and x is work or forwarding;

precondition (x) represents condition calculation, the result is True or False, and x is forwarding;

count (x) represents the number of objects in a collection, x being a collection.

The scheduling method of the multi-step task can be expressed as follows:

1 deg. start-up case.

Let w₀As a casei any initial work of, W₀Is w₀The scheduling method of the start case is as follows:

the status of the case and each of the initial jobs is set to the in-office status. Namely, it is

SetStatus(1)：＝Si_w

SetStatus(w₀)：＝Sw_w，*w₀∈W₀。

2 ° end case

Let W be any work of case i, W be the set of W, D be any forwarding of case i, and D be the set of D, then the scheduling method of the terminating case is:

the first step is as follows: if there are still jobs to be done or tasks to be signed in a case, i.e. <math> <mrow> <mi>GetStatus</mi> <mrow> <mo>(</mo> <mi>w</mi> <mo>)</mo> </mrow> <mo>=</mo> <mi>S</mi> <msub> <mi>w</mi> <mi>w</mi> </msub> <mo>,</mo> <mo>&Exists;</mo> <mi>w</mi> <mo>&Element;</mo> <mi>W</mi> </mrow> </math> Or <math> <mrow> <mi>GetStatus</mi> <mrow> <mo>(</mo> <mi>d</mi> <mo>)</mo> </mrow> <mo>=</mo> <mi>S</mi> <msub> <mi>d</mi> <mi>w</mi> </msub> <mo>,</mo> <mo>&Exists;</mo> <mi>d</mi> <mo>&Element;</mo> <mi>D</mi> <mo>,</mo> </mrow> </math> The case can not be terminated and the process is ended; otherwise, the second step is carried out.

The second step is that: setting the state of the case to be a complete state, namely SetStatus (i): is Si ═ Si_f。

And 3 degrees of client machines sign the tasks.

Let c be any client of the case order, g_cIs any packet defined on c, d packets g_cD is a set of D,'t is a task to which D belongs,dis any forwarding in the task't,Dis thatdSet of (2)'W is any work in task't, 'W is a set of' W, W is a grouping g_cW is the set of W, t is the task to which W belongs,wis any one of the jobs in the task t,Wis thatwD ' is any forwarding in task t, D ' is a set of D '. The scheduling method of the client c to sign up the task is as follows:

the first step is as follows: if g is_cIs in a pending or negative state, i.e., GetStatus (d) e { Sd_w，Sd_nThe * D belongs to D, then the second step is carried out; otherwise, ending;

the second step is that: if g is_cIs in a negative state, i.e. getstatus (d) ═ Sd_n* D belongs to D, then go to the third step; otherwise, turning to the fourth step;

the third step: g is prepared from_cIs set to a negative state, namely setstatus (w): sw_n* W ∈ W; for each w, if it belongs to each work of task twAre all in a negative state, i.e. GetStatus: (w)＝Sw_n，* w∈ WThen task t and each forwarding d' of task t are set to a negative state, i.e. setstatus (t): st-_nSetStatus(d′)：＝Sd_n* D' is equal to D, and ends; otherwise, ending.

The fourth step: for g_cIf it is in the ready state, set the client of d to c, i.e. setclient (d): if c, turning to the sixth step; otherwise, set the client of d to null, i.e., setclient (d): null, and go to the fifth step;

the fifth step: if the task't to which d belongs is in a negative state, namely GetStatus ('t): st-_nThen task't and each of its jobs' w and each of its forwardingsdSet to the done state, SetStatus ('t): st-_f，SetStatus(′w)：＝Sw_f，*′w∈′W，SetStatus( d)：＝Sd_f，* d∈ D；

And a sixth step: g is prepared from_cSet to completion status, set each work w to completion status, and set the client of each work w to c, setstatus (d): sd ═ Sd_f，*d∈D，SetClient(w)：＝c，*w∈W，SetStatus(w)：＝Sw_w* W ∈ W. If g is_cThe forwarding d is still in the pending or negative state, i.e. GetStatus (d) epsilon { Sd_w，Sd_nFourthly, * D belongs to D, then the fourth step is carried out; otherwise, turning to the seventh step.

The seventh step: if task t is ready, i.e. GetStatus (t) St_rThen task t is set to be in the office state, i.e., setstatus (t): st-_w；

Eighth step: client c transacts g_cAny of which works w.

The ninth step: if the work w is done, the work w is set to a completion state, namely setstatus (w): sw_f. If g is_cStill in the on-hold state, i.e. <math> <mrow> <mi>GetStatus</mi> <mrow> <mo>(</mo> <mi>w</mi> <mo>)</mo> </mrow> <mo>=</mo> <mi>S</mi> <msub> <mi>w</mi> <mi>w</mi> </msub> <mo>,</mo> <mo>&Exists;</mo> <mi>w</mi> <mo>&Element;</mo> <mi>W</mi> <mo>,</mo> </mrow> </math> Rotating to the eighth step; otherwise, ending.

The 4 client returns to the task.

Let c be any client of the case order, g_cIs any packet defined on c, d is a packet g_cD is a set of D,'t is a task to which D belongs,dis any forwarding in the task't,Dis thatdIs any work in task't, ' W is a set of ' W, W is a packet g_cW is the set of W, t is the task to which W belongs, wis any one of the jobs in the task t,Wis thatwD ' is any forwarding in task t, and D ' is a set of D ', then the scheduling method for client c to return to the task is as follows:

the first step is as follows: if g is_cIs in an on state, i.e. GetStatus (w) ═ Sw_w* W belongs to W, then the second step is carried out; otherwise, ending.

The second step is that: g is prepared from_cIs set to the ready state, setstatus (w): sw_r* W ∈ W. For g_cIf w belongs to each work of task twAre all in the ready state, i.e., GetStatus: (w)＝Sw_r，* w∈ WThen task t is set to the ready state, setstatus (t): st-_r。

The third step: for g_cIf the client is c, i.e., getclient (d) ═ c, then the client of d is set to null, and d is set to the to-be-signed state, i.e., setclient (d): null, setstatus (d): sd ═ Sd_wThen, turning to the fifth step; otherwise, set d to a negative state, i.e., setstatus (d): sd ═ Sd_nAnd then turning to the fourth step.

The fourth step: if each forwarding of the task't to which d belongsdAre all in the negative state, i.e. GetStatus (d) ═ Sd_n，* d∈ DAnd each client working on ' W for task't is null, i.e. GetClient (' W) ═ null, * ' W ∈ ' W, then task't is set to the negative state, i.e. SetStatus ('t): st-_n. And (6) ending.

5 deg. multi-step task handling.

Let t be any task in the case, W be any work of task t, W be the set of W, c be the client responsible for handling work W, g_cIs any packet defined on client c, and'd is packet g_cIs a set of 'D,'t is a work to which 'D belongs,' W is any work of task't,' W is a set of 'W'dIs any forward of't'DIs'dThe set of (a) and (b),wis a packet g_cIn the above-mentioned manner, any one of the operations,Wis thatwD is any forwarding of the task t, D is the set of D, c' is the client to which D belongs, g_c'is any packet defined on client c',dis a packet g_cEither of the above-mentioned' forwarding is carried out,Dis thatdW' is a packet g_c'any work in W', W 'is a set of W', t 'is a task to which W' belongs,w'is any one of the jobs in the task t',W' isw' D ' is any forwarding of t ' and D ' is a set of D '. The scheduling method of the task t handling process is as follows:

the first step is as follows: if every work w of task t is in the complete or negative state, i.e. GetStatus (w) e { Sw_f，SW_n}， If W belongs to W, then switching to the second step; otherwise, ending.

The second step is that: if every task w of task t is in negative state, i.e. getstatus (w) Sw_n， w∈W,

Set task t and each forwarding d of task t to a negative state, setstatus (t): st-_n SetStatus(d)：＝Sd_n* D ∈ D, then go to the seventh step; otherwise, the third step is carried out.

The third step: for any w in t, if w is in a negative state, then w is set to a complete state, the client of w is set to null, and w will be in the same group g as w_cEach of which operateswAnd each forwarding'd is set to a completion state, setstatus (w): sw_f，SetClient(w)：＝null，SetStatus( w)＝Sw_f，* w∈ W，SetStatus(′d)＝Sd_f* 'D ∈' D, then go to the fourth step; otherwise, turning to the fifth step.

The fourth step: for any'd, if the task't to which the'd belongs is in a negative state, i.e. GetStatus ('t) ═ St_nThen each of task't and task't is forwarded 'dSet to the done state, SetStatus ('t): st-_f，SetStatus(′ d)：＝Sd_f，*′ d∈′ D。

The fifth step: if task t has work w in negative state, i.e. <math> <mrow> <mi>GetStatus</mi> <mrow> <mo>(</mo> <mi>w</mi> <mo>)</mo> </mrow> <mo>=</mo> <mi>S</mi> <msub> <mi>w</mi> <mi>n</mi> </msub> <mo>,</mo> <mo>&Exists;</mo> <mi>w</mi> <mo>&Element;</mo> <mi>W</mi> <mo>,</mo> </mrow> </math> Turning to the third step; otherwise, the step six is executed.

And a sixth step: setting task t to completion state, i.e. <math> <mrow> <mi>SetStatud</mi> <mrow> <mo>(</mo> <mi>t</mi> <mo>)</mo> </mrow> <mo>:</mo> <mo>=</mo> <msub> <mi>St</mi> <mi>f</mi> </msub> <mo>,</mo> <mo>&Exists;</mo> <mi>w</mi> <mo>&Element;</mo> <mi>W</mi> <mo>.</mo> </mrow> </math> Calculating a forwarding condition of each forwarding d of the task t, and if the result is True, namely precondition (d) True, setting the forwarding d to a to-be-signed state, namely setstatus (d): sd ═ Sd_w(ii) a Otherwise forward d is set to negative state, i.e. setstatus (d): sd ═ Sd_n。

The seventh step: for any d, if it belongs to the group g_cAll forwarding in `dIn the negative state, i.e. GetStatus: (d)＝Sd_n，* d∈ DThen group g will be grouped_cAll work w ' in ' is set to negative state, i.e. SetStatus (w '): is SW_n，*w′∈W′。

Eighth step: for any one w ', all jobs in task t' if it belongs tow' in a negative state, i.e. GetStatusS ((R))w′)＝Sw_n，* w′∈ W', then all forwarding d ' of task t ' and task t ' are set to negative state, i.e. SetStatus (t '): st-_n SetStatus(d′)＝Sd_n，*d′∈D′。

6 degrees of multi-step task reprocessing.

Let t be any task in the case, W be any work of task t, W be the set of W, c be the client responsible for handling work W, g_cIs any packet defined on client c, and'd is packet g_cIs a set of 'D,'t is a work to which 'D belongs,' W is any work of task't,' W is a set of 'W'dIs any forward of't'DIs'dThe set of (a) and (b),wis a packet g_cIn the above-mentioned manner, any one of the operations,Wis thatwD is any forwarding of the task t, D is the set of D, c' is the client to which D belongs, g_c'is any packet defined on client c',dis a packet g_cEither of the above-mentioned' forwarding is carried out,Dis thatdW' is a packet g_c'any work in W', W 'is a set of W', t 'is a task to which W' belongs,w'is any one of the jobs in the task t',W' isw' D ' is any forwarding of t ' and D ' is a set of D '. The scheduling method for client c to redo task t is as follows:

the first step is as follows: if task t is in the on-hold state, i.e., GetStatus (t) St_wOr task t is in completion and task t is not forwarded, i.e. getstatus (t) St_f &Count (d) 0, or task t is in complete state and each forwarding d of task t is in pending or negative state, i.e. getstatus (t) St_f & GetStatus(d)∈{Sd_w，Sd_nThe * D belongs to D, then the second step is carried out; otherwise, ending.

The second step is that: for any d, if it belongs to the group g_c' Each of the forwardingdAre all in a negative state, i.e. GetStatus: (d)＝Sd_n，* d∈ DThen group g will be grouped_cAll jobs w ' in ' are set to the ready state, SetStatus (w '): sw_r* W 'is belonged to W', and then the third step is carried out; otherwise, turning to the fourth step.

The third step: for any w ', if the task t' to which it belongs is in a negative state, each forwarding d 'of the task t' and the task t 'is set to a ready state, i.e., SetStatus (t'): st-_r SetStatus(d′)＝Sd_r，*d′∈D′。

The fourth step: setting the task t and the work w to be reworked by the task t as an on-office state, and setting each forwarding d of the task t as a ready state, namely SetStatus (w): sw_w，SetStatus(t)：＝St_w，SetStatus(d)：＝Sd_r* D ∈ D. For any d, if it belongs to the group g_cWith work W' in the negative state, i.e. <math> <mrow> <mi>GetStatus</mi> <mrow> <mo>(</mo> <msub> <mi>w</mi> <mo>&prime;</mo> </msub> <mo>)</mo> </mrow> <mo>=</mo> <msub> <mi>Sw</mi> <mi>n</mi> </msub> <mo>,</mo> <mo>&Exists;</mo> <msup> <mi>w</mi> <mo>&prime;</mo> </msup> <mo>&Element;</mo> <msup> <mi>W</mi> <mo>&prime;</mo> </msup> <mo>,</mo> </mrow> </math> Will group g_c' each work w ' in the set is set to the ready state, SetStatus (w '): sw_r，*w′∈W′。

The fifth step: if task t has work w in completion and the client of w is null, i.e. $\mathrm{GetStatus}\left(w\right)={\mathrm{Sw}}_f$ & <math> <mrow> <mi>GetClient</mi> <mrow> <mo>(</mo> <mi>w</mi> <mo>)</mo> </mrow> <mo>=</mo> <mi>null</mi> <mo>,</mo> <mo>&Exists;</mo> <mi>w</mi> <mo>&Element;</mo> <mi>W</mi> <mo>,</mo> </mrow> </math> Put w to the negative state, setstatus (w): sw_n。

And a sixth step: for any one w in t, if w belongs to a group g_cIs in a negative state, i.e. GetStatus (b) ((b))w)＝Sw_n，* w∈ WThen g is_cSet to a negative state, SetStatus ('d): sd ═ Sd_n，*′d∈′D。

The seventh step: for any'd, if its task't is in completion and the client of each work ' w of the task't is null, i.e. GetStatus ('t) ═ St_f &GetClient (' W) ═ null, * ' W ∈ ' W, then each job ' W of task't and task't is set to a negative state, SetStatus ('t): st-_n SetStatus(′w)：＝Sw_n，*′w∈′W。

Eighth step: client c reworks job w.

The ninth step: if the work w is finished, setting the work w to be in a finished state, namely SetStatus (w): sw_fAnd then, the process is ended. Otherwise, the step eight is executed.

The cycle is started at 7 deg..

Let L be any cycle of case i, and w be any work on the cycle path, then the scheduling method of the start cycle is as follows:

if the work w belongs to the loop L and the work w is in the on-Do state and the loop L is in the ready state, i.e. w belongs to L&GetStatus(w)＝Sw_w&GetStatus(L)＝Sl_rThen set cycle L to run state, setstatus (L): sl ═ Sl_w(ii) a Otherwise, ending.

The cycle is terminated at 8 °.

Let L be any cycle of case i, and w be any work on the cycle path, then the scheduling method for terminating the cycle is as follows:

if the work w belongs to the loop L, the work w is in the on state and the loop L is in the running state, namely w belongs to the L&GetStatus(w)＝Sw_w&GetStatus(L)＝Sl_wThen set cycle L to run state, setstatus (L): sl ═ Sl_f(ii) a Otherwise, ending.

The invention realizes a cooperation method between the multi-step tasks and the clients and a forward and reverse scheduling method of the multi-step tasks when the tasks are completed on the clients in stages in the multi-task scheduling of the workflow, wherein the scheduling method comprises a starting case, a terminating case, a client signing task, a client returning task, a multi-step task handling, a multi-step task reprocessing, a starting cycle and a terminating cycle. Through the actual test of the workflow engine software based on the scheduling method, the scheduling method completely meets the requirements, and the aim of the invention is well fulfilled.

Drawings

FIG. 1 is a flow chart of the case start scheduling of the present invention

FIG. 2 is a flow chart of the case termination scheduling of the present invention

FIG. 3 is a schematic diagram of client sign-on and return tasks according to the present invention

FIG. 4 is a flow chart of a client sign-on task of the present invention

FIG. 5 is a flow chart of the client return task of the present invention

FIG. 6 is a schematic diagram of task handling and re-handling according to the present invention

FIG. 7 is a task processing flow diagram of the present invention

FIG. 8 is a task re-processing flow chart of the present invention

FIG. 9 is a flow chart of a start-up cycle of the present invention

FIG. 10 is a flow chart of the termination cycle of the present invention

FIG. 11 is a schematic view of an embodiment of the present invention

Detailed Description

As shown with reference to figure 1 of the drawings,

let w₀For any initial job of case i, W₀Is w₀The scheduling method of the start case is as follows:

the status of the case and each of the initial jobs is set to the in-office status. Namely, it is

SetStatus(i)：＝Si_w

SetStatus(w₀)：＝Sw_w，*w₀∈W₀。

As shown with reference to figure 2 of the drawings,

let W be any work of case i, W be the set of W, D be any forwarding of case i, and D be the set of D, then the scheduling method of the terminating case is:

the first step is as follows: if there are still jobs to be done or tasks to be signed in a case, i.e. <math> <mrow> <mi>GetStatus</mi> <mrow> <mo>(</mo> <mi>w</mi> <mo>)</mo> </mrow> <mo>=</mo> <mi>S</mi> <msub> <mi>w</mi> <mi>w</mi> </msub> <mo>,</mo> <mo>&Exists;</mo> <mi>w</mi> <mo>&Element;</mo> <mi>W</mi> </mrow> </math> Or <math> <mrow> <mi>GetStatus</mi> <mrow> <mo>(</mo> <mi>d</mi> <mo>)</mo> </mrow> <mo>=</mo> <msub> <mi>Sd</mi> <mi>w</mi> </msub> <mo>,</mo> <mo>&Exists;</mo> <mi>d</mi> <mo>&Element;</mo> <mi>D</mi> <mo>,</mo> </mrow> </math> The case can not be terminated and the process is ended; otherwise, the second step is carried out.

The second step is that: setting the state of the case to be a complete state, namely SetStatus (i): is Si ═ Si_f。

As shown with reference to figure 3 of the drawings,

let c be any client in case i, g_cIs any packet defined on c, d is a packet g_cD is a set of't is the task to which D belongs, D is any forwarding in task't,Dis thatdIs any work in task't, ' W is a set of ' W, W is a packet g_cW is a set of W, t is a task to which W belongs, W is any one of tasks t,Wis thatwD ' is any forwarding in task t, D ' is a set of D '.

As shown with reference to figure 4 of the drawings,

let c be any client in case i, g_cIs any packet defined on c, d is a packet g_cD is a set of't is the task to which it belongs, D is any forwarding in task't,Dis thatdIs any work in task't, ' W is a set of ' W, W is a packet g_cW is the set of W, t is the task to which W belongs,wis any one of the jobs in the task t,Wis thatwD ' is any forwarding in task t, D ' is a set of D '. The scheduling method of the client c to sign up the task is as follows:

the first step is as follows: if g is_cIs forwarded tod are all in the pending or negative state, i.e., GetStatus (d) e { Sd_w，Sd_nThe * D belongs to D, then the second step is carried out; otherwise, ending;

the second step is that: if g is_cIs in a negative state, i.e. getstatus (d) ═ Sd_n* D belongs to D, then go to the third step; otherwise, turning to the fourth step;

the third step: g is prepared from_cIs set to a negative state, namely setstatus (w): sw_n* W ∈ W; for each w, if it belongs to each work of task twAre all in a negative state, i.e. GetStatus: (w)＝Sw_n，* w∈ WThen task t and each forwarding d' of task t are set to a negative state, i.e. setstatus (t): st-_nSetStatus(d′)：＝Sd_n* D 'is E.D', end; otherwise, ending.

The fourth step: for g_cIf it is in the ready state, set the client of d to c, i.e. setclient (d): if c, turning to the sixth step; otherwise, set the client of d to null, i.e., setclient (d): null, and go to the fifth step;

the fifth step: if the task't to which d belongs is in a negative state, namely GetStatus ('t): st-_nThen task't and each of its jobs' w and each of its forwardingsdSet to the done state, SetStatus ('t): st-_f，SetStatus(′w)：＝Sw_f，*′w∈′W，SetStatus( d)：＝Sd_f，* d∈ D；

And a sixth step: g is prepared from_cSet to completion status, set each work w to completion status, and set the client of each work w to c, setstatus (d): sd ═ Sd_f，*d∈D，SetClient(w)：＝c，*w∈W，SetStatus(w)：＝Sw_w* W ∈ W. If g is_cIn which the forwarding d is still pendingA sign-on or a-off state, i.e., GetStatus (d) e { Sd_wSdn }, * D ∈ D, then go to the fourth step; otherwise, turning to the seventh step.

The seventh step: if task t is ready, i.e. GetStatus (t) St_rThen task t is set to be in the office state, i.e., setstatus (t): st-_w；

Eighth step: client c transacts g_cAny of which works w.

The ninth step: if the work w is done, the work w is set to a completion state, namely setstatus (w): sw_f。

If g is_cStill in the on-hold state, i.e. <math> <mrow> <mi>GetStatus</mi> <mrow> <mo>(</mo> <mi>w</mi> <mo>)</mo> </mrow> <mo>=</mo> <msub> <mi>Sw</mi> <mi>w</mi> </msub> <mo>,</mo> <mo>&Exists;</mo> <mi>w</mi> <mo>&Element;</mo> <mi>W</mi> <mo>,</mo> </mrow> </math> Rotating to the eighth step; otherwise, ending.

As shown with reference to figure 5 of the drawings,

let c be any client in case i, g_cIs any packet defined on c, d is a packet g_cD is a set of D,'t is a task to which D belongs,dis any forwarding in the task't,Dis thatdIs any work in task't, ' W is a set of ' W, W is a packet g_cW is the set of W, t is the task to which W belongs,wis any one of the jobs in the task t,Wis thatwD ' is any forwarding in task t, and D ' is a set of D ', then the scheduling method for client c to return to the task is as follows:

the first step is as follows: if g is_cIs in an on state, i.e. GetStatus (w) ═ Sw_w* W belongs to W, then the second step is carried out; otherwise, ending.

The second step is that: g is prepared from_cIs set to the ready state, setstatus (w): sw_r* W ∈ W. For g_cIf w belongs to each work of task twAre all in the ready state, i.e. GetStatus (w) ═ Sw_r，* w∈ WThen task t is set to the ready state, setstatus (t): st-_r。

The third step: for g_cIf the client is c, i.e., getclient (d) ═ c, then the client of d is set to null, and d is set to the to-be-signed state, i.e., setclient (d): null, setstatus (d): sd ═ Sd_wThen, turning to the fifth step; otherwise, set d to a negative state, i.e., setstatus (d): sd ═ Sd_nAnd then turning to the fourth step.

The fourth step: if each forwarding of the task't to which d belongsdAre all in a negative state, i.e. GetStatus: (d)＝Sd_n，*d∈ DAnd each client working on ' W for task't is null, i.e. GetClient (' W) ═ null, * ' W ∈ ' W, then task't is set to the negative state, i.e. SetStatus ('t): st-_n. And (6) ending.

As shown with reference to figure 6 of the drawings,

let t be any task in the case, W be any work of task t, W be the set of W, c be the client responsible for handling work W, g_cIs any packet defined on client c, and'd is packet g_cIs a set of 'D,'t is a work to which 'D belongs,' W is any work of task't,' W is a set of 'W'dIs any forward of't'DIs'dThe set of (a) and (b),wis a packet g_cIn the above-mentioned manner, any one of the operations,Wis thatwD is any forwarding of the task t, D is the set of D, c' is the client to which D belongs, g_c'is any packet defined on client c',dis a packet g_cEither of the above-mentioned' forwarding is carried out,Dis thatdW' is a packet g_c'any work in W', W 'is a set of W', t 'is a task to which W' belongs,w'is any one of the jobs in the task t',W' isw' D ' is any forwarding of t ' and D ' is a set of D '.

As shown with reference to figure 7 of the drawings,

let t be any task in the case, W be any work of task t, W be the set of W, c be the client responsible for handling work W, g_cIs any packet defined on client c, and'd is packet g_cIs a set of 'D,'t is a work to which 'D belongs,' W is any work of task't,' W is a set of 'W'dIs any forward of't'DIs'dThe set of (a) and (b),wis a packet g_cIn the above-mentioned manner, any one of the operations,Wis thatwD is any forwarding of the task t, D is the set of D, c' is the client to which D belongs, g_c'is any packet defined on client c',dis a packet g_cEither of the above-mentioned' forwarding is carried out,Dis thatdW' is a packet g_c'any work in W', W 'is a set of W', t 'is a task to which W' belongs,w'is any one of the jobs in the task t',W' isw' D ' is any forwarding of t ' and D ' is a set of D '. The scheduling method of the task t handling process is as follows:

the first step is as follows: if every work w of task t is in the complete or negative state, i.e. GetStatus (w) e { Sw_f，Sw_n}， If W belongs to W, then switching to the second step; otherwise, ending.

The second step is that: if every task w of task t is in negative state, i.e. getstatus (w) Sw_n，

W ∈ W, then set task t and each forwarding d of task t to a negative state, i.e. setstatus (t): st-_n SetStatus(d)：＝Sd_n* D ∈ D, then go to the seventh step; otherwise, the third step is carried out.

The third step: for any w in t, if w is in a negative state, then w is set to a complete state, the client of w is set to null, and w will be in the same group g as w_cEach of which operateswAnd each forwarding'd is set to a completion state, setstatus (w): sw_f，SetClient(w)：＝null，SetStatus( w)＝Sw_f，* w∈ W，SetStatus(′d)＝Sd_f* 'D ∈' D, then go to the fourth step; otherwise, turning to the fifth step.

The fourth step: for any'd, if the task't to which the'd belongs is in a negative state, i.e. GetStatus ('t) ═ St_nThen each of task't and task't is forwarded 'dSet to the done state, SetStatus ('t): st-_f，SetStatus(′ d)：＝Sd_f，*′ d∈′ D。

The fifth step: if task t has work w in negative state, i.e. <math> <mrow> <mi>GetStatus</mi> <mrow> <mo>(</mo> <mi>w</mi> <mo>)</mo> </mrow> <mo>=</mo> <msub> <mi>Sw</mi> <mi>n</mi> </msub> <mo>,</mo> <mo>&Exists;</mo> <mi>w</mi> <mo>&Element;</mo> <mi>W</mi> <mo>,</mo> </mrow> </math> Turning to the third step; otherwise, the step six is executed.

And a sixth step: setting task t to completion state, i.e. <math> <mrow> <mi>SetStatus</mi> <mrow> <mo>(</mo> <mi>t</mi> <mo>)</mo> </mrow> <mo>:</mo> <mo>=</mo> <msub> <mi>St</mi> <mi>f</mi> </msub> <mo>,</mo> <mo>&Exists;</mo> <mi>w</mi> <mo>&Element;</mo> <mi>W</mi> <mo>.</mo> </mrow> </math> Calculating a forwarding condition of each forwarding d of the task t, and if the result is True, namely precondition (d) True, setting the forwarding d to a to-be-signed state, namely setstatus (d): sd ═ Sd_w(ii) a Otherwise forward d is set to negative state, i.e. setstatus (d): sd ═ Sd_n。

The seventh step: for any d, if it belongs to the group g_cAll forwarding in `dIn the negative state, i.e. GetStatus: (d)＝Sd_n，* d∈ DThen group g will be grouped_cAll jobs in ' w ' are set to a negative state, i.e. SetStatus (w '): sw_n，*w′∈W′。

Eighth step: for any one w ', all jobs in task t' if it belongs tow' in a negative state, i.e. GetStatusS ((R))w′)＝Swn，* w′∈ W', then all forwarding d ' of task t ' and task t ' are set to negative state, i.e. SetStatus (t '): st-_n SetStatus(d′)＝Sd_n，*d′∈D′。

As shown with reference to figure 8 of the drawings,

let t be any task in the case, W be any work of task t, W be the set of W, c be the client responsible for handling work W, g_cIs any packet defined on client c, and'd is packet g_cIs a set of 'D,'t is a work to which 'D belongs,' W is any work of task't,' W is a set of 'W'dIs any forward of't'DIs'dThe set of (a) and (b),wis a packet g_cIn the above-mentioned manner, any one of the operations,Wis thatwD is the task's task ofOne forwarding, D is the set of D, c' is the client to which D belongs, g_c'is any packet defined on client c',dis a packet g_cEither of the above-mentioned' forwarding is carried out,Dis thatdW' is a packet g_c'any work in W', W 'is a set of W', t 'is a task to which W' belongs,w'is any one of the jobs in the task t',W' isw' D ' is any forwarding of t ' and D ' is a set of D '. The scheduling method for client c to redo task t is as follows:

the first step is as follows: if task t is in the on-hold state, i.e., GetStatus (t) St_wOr task t is in completion and task t is not forwarded, i.e. getstatus (t) St_f&Count (d) 0, or task t is in complete state and each forwarding d of task t is in pending or negative state, i.e. getstatus (t) St_f&GetStatus(d)∈{Sd_w，Sd_nThe * D belongs to D, then the second step is carried out; otherwise, ending.

The second step is that: for any d, if it belongs to the group g_c' Each of the forwardingdAre all in a negative state, i.e. GetStatus: (d)＝Sd_n，* d∈ DThen group g will be grouped_cAll jobs w ' in ' are set to the ready state, SetStatus (w '): sw_r* W 'is belonged to W', and then the third step is carried out; otherwise, turning to the fourth step.

The third step: for any w ', if the task t' to which it belongs is in a negative state, each forwarding d 'of the task t' and the task t 'is set to a ready state, i.e., SetStatus (t'): st-_r SetStatus(d′)＝Sd_r，*d′∈D′。

The fourth step: setting the task t and the work w to be reworked by the task t as an on-office state, and setting each forwarding d of the task t as a ready state, namely SetStatus (w): sw_w，SetStatus(t)：＝St_w，SetStatus(d)：＝Sd_r* D ∈ D. For any d, if it belongs to the group g_c'with work w' in negative, i.e. <math> <mrow> <mi>GetStatus</mi> <mrow> <mo>(</mo> <msup> <mi>w</mi> <mo>&prime;</mo> </msup> <mo>)</mo> </mrow> <mo>=</mo> <msub> <mi>Sw</mi> <mi>n</mi> </msub> <mo>,</mo> <mo>&Exists;</mo> <msup> <mi>w</mi> <mo>&prime;</mo> </msup> <mo>&Element;</mo> <msup> <mi>W</mi> <mo>&prime;</mo> </msup> <mo>,</mo> </mrow> </math> Will group g_c' each work w ' in the set is set to the ready state, SetStatus (w '): sw_r，*w′∈W′。

The fifth step: if task t has work w in completion and the client of w is null, i.e. $\mathrm{GetStatus}\left(w\right)={\mathrm{Sw}}_f$ & <math> <mrow> <mi>GetClient</mi> <mrow> <mo>(</mo> <mi>w</mi> <mo>)</mo> </mrow> <mo>=</mo> <mi>null</mi> <mo>,</mo> <mo>&Exists;</mo> <mi>w</mi> <mo>&Element;</mo> <mi>W</mi> <mo>,</mo> </mrow> </math> Set w to a negative state, setstatus (w): sw_n。

And a sixth step: for any one w in t, if w belongs to a group g_cEach of which operateswAre all in a negative state, i.e. GetStatus: (w)＝Sw_n，* w∈ WThen g is_cSet to a negative state, SetStatus ('d): sd ═ Sd_n，*′d∈′D。

The seventh step: for any'd, if its task't is in completion and the client of each work ' w of the task't is null, i.e. GetStatus ('t) ═ St_f&GetClient(′w)＝null，*′w∈' W, then set task't and each job ' W of task't to a negative state, SetStatus ('t): st-_n SetStatus(′w)：＝Sw_n，*′w∈′W。

Eighth step: client c reworks job w.

The ninth step: if the work w is done, the work w is set to a completion state, namely setstatus (w): sw_fAnd then, the process is ended. Otherwise, the step eight is executed.

As shown with reference to figure 9 of the drawings,

let L be any cycle of case i, and w be any work on the cycle path, then the scheduling method of the start cycle is as follows:

if the work w belongs to the loop L and the work w is in the on-Do state and the loop L is in the ready state, i.e. w belongs to L&GetStatus(w)＝Sw_w&GetStatus(L)＝Sl_rThen set cycle L to run state, setstatus (L): sl ═ Sl_w(ii) a Otherwise, ending.

As shown with reference to figure 10 of the drawings,

let L be any cycle of case i, and w be any work on the cycle path, then the scheduling method for terminating the cycle is as follows:

if the work w belongs to the loop L, the work w is in the on state and the loop L is in the running state, namely w belongs to the L&GetStatus(w)＝Sw_w&GetStatus(L)＝Sl_wThen set cycle L to run state, setstatus (L): sl ═ Sl_f(ii) a Otherwise, ending.

As shown with reference to figure 11 of the drawings,

there are 6 clients (c1, c2, c3, c4, c5 and c6) and 7 tasks (t1, t2, t3, t4, t5, t6, t7) in case i, where tasks t1, t5 and t7 are multi-step tasks (completed in steps across multiple clients), work w1_1, w1_1 and w _5 are initiating work, forwarding d1_1 and d1_2 are conditional forwarding, 2 packets are defined on c6, d2 and w6_2 are packets g1, d1_2 and w6_1 are packets g2, all other clients that do not define packets default to the same packet, w2_1, d4, w3_1 and d3 are a loop l.

The multi-step task collaborative network can be represented graphically, which is called a network diagram for short. In this embodiment, a graphical representation method as in fig. 11 is employed: clients are represented by circles, tasks are represented by rectangles, work and forwarding are represented by lines with arrows, initial work and conditional forwarding are represented by open arrows, loops are represented by small circles at the beginning of the lines (only loops are used as open), and packets are represented by numbers marked on the lines near the client end.

All work, tasks, forwarding, and loops in the case and case are in a ready state before the case is not started.

1. Forward scheduling example for case i.

(1) When i is activated, s (i) ═ Si_w，S(w1_1)＝Sw_w，S(w1_1)＝Sw_w，S(w_5)＝Sw_w，S(t1)＝St_w，S(t2)＝St_w。

(2) As can be seen from the figure, t1 is responsible for c1 and c5 simultaneously, corresponding to works w1_1 and w5, t2 is responsible for c1, corresponding to work w1_ 2.

(3) When w1_1 and w5 are finished, S (w1_1) is Sw_f，S(w5)＝Sw_f，S(t1)＝St_fSince d1_1 and d1_2 are conditional forwarding, conditional judgment needs to be performed according to condition setting, where P (d1_1) is True and P (d1_2) is False, S (d1_1) is Sd_w，S(d1_2)＝Sd_n。

(4) When w1_2 is finished, S (w1_2) is Sw_f，S(t2)＝St_f，S(d2)＝Sd_w。

(5) c2 does not define a packet, defaulting to all forwarding and working as a group. Since d3 is only used for loop (active when loop is started), and no loop is assumed to be started, c2 can sign task t1, and after the sign, S (d1_1) ═ Sd_f，S(w2_1)＝Sw_w，S(w2_1)＝Sw_n，S(t4)＝St_w，S(t5)＝St_w。

(6) 2 groups are defined on c6, d2 and w6_2 are groups g1, and d1_2 and w6_1 are groups g 2. For g1, after c6 signs task t2, S (d2) is Sdf, and S (w6_2) is Sw_w，S(t6)＝St_w. For g2, S (d1 — 2) ═ Sd_nSo S (w6_1) ═ Sw_n。

(7) When w2_1 is finished, S (w2_1) is Sw_f，S(t4)＝St_f，S(d4)＝Sd_w。

(8) When w2_2 is finished, S (w2_2) is Sw_fSince S (w6_1) ═ Sw_n，S(t5)＝St_f，S(d5_1)＝Sd_w，S(d5_2)＝Sd_w。

(9) When w6_2 is finished, S (w6_2) is Sw_f，S(t6)＝St_f。

(10) c3 does not define a packet, defaulting to all forwarding and working as a group. Since w3_1 is for loop only, and it is assumed here that loop is not started, S (d4) Sd after c3 signs tasks t4 and t5_f，S(d5_1)＝Sd_f，S(w3_2)＝Sw_w。

(11) c4 does not define a packet, defaulting to all forwarding and working as a group. c4 signs task t5, S (d5_2) ═ Sd_f，S(w4)＝Sw_w。

(12) When w3_2 and w4 are finished, S (w3_2) is Sw_f，S(w4)＝Sw_f，S(t7)＝St_fI ends because none of w and d in i is in the pending or signed state, s (i) ═ Si_f。

2. Example of a reverse scheduling process for a case.

(1) The client machine reworks the task:

let case i schedule forward to step (4), since S (d1_1) ═ Sd_w，S(d1_2)＝Sd_n，S(d1_2)＝Sd_nTherefore, c5 can redo t1, c1 can redo t1 and t1t 2. Here, let c1 redo t1, and after redo, S (d1_1) ═ Sd_r，S(d1_2)＝Sd_r，S(t1)＝St_w，S(w1_1)＝Sw_w。

(2) The client returns to the task:

let case i forward schedule to step (6), since S (w2_1) ═ Sw_w，S(w2_1)＝Sw_n，S(w6_1)＝Sw_n，S(w6_2)＝Sw_w，S(t4)＝St_w，S(t5)＝St_w，S(t6)＝St_wSo both c2 and c6 can roll back to the task. Assuming that c6 returns signed task t2 of group g1, S (w6_2) is Sw_r，S(d2)＝Sd_w. It can be seen that c1 can also redo w1_2 when c6 rolls back to signed t2, thereby continuously implementing the reverse direction in the multi-step task scheduling process.

3. Example of a round-robin scheduling process for a case.

If case i is scheduled forward to step (10), c3 starts loop l, then s (l) Sl_w，S(w3_1)＝Sw_w，S(t3)＝St_w(ii) a When w3_1 is finished, S (w3_1) is Sw_f，S(t3)＝St_f，S(d3)＝Sd_w(ii) a At this time, c2 may sign task t3, and since the cycle handles the work, task, and forwarding in the path together as ready, and w2_2 is not in the cycle, S (d3) after signing is Sd_f，S(2_1)＝Sw_w，S(t4)＝St_w(ii) a When w2_1 is finished, S (w2_1) is Sw_f，S(t4)＝St_f，S(d4)＝Sd_w(ii) a At this time, if the cycle is stopped at c3, s (l) ═ Sl_fThe loop ends, ce can then process w3_1 if the loop is not to be aborted, S (w3_1) ═ Sw_w，S(t3)＝St_wAnd repeating the circulation in such a way until the circulation is terminated.

Claims (1)

1. A multitask cooperative scheduling method for a workflow engine is characterized by comprising the following steps: the method comprises the following steps:

(i) constructing a computing model of a multi-task cooperative method, namely a multi-step task cooperative network, wherein a four-tuple N ═ C, T; W, D) is constructed according to the following sufficient requirements:

1°C≠φ

2°T≠φ

3°CI T＝φ

4°W*C×T

5°D*T×C

6°dom(W)Y cod(W)＝CYT

wherein, <math> <mrow> <mi>dom</mi> <mrow> <mo>(</mo> <mi>W</mi> <mo>)</mo> </mrow> <mo>=</mo> <mo>{</mo> <mi>x</mi> <mo>|</mo> <mo>&Exists;</mo> <mi>y</mi> <mo>:</mo> <mrow> <mo>(</mo> <mi>x</mi> <mo>,</mo> <mi>y</mi> <mo>)</mo> </mrow> <mo>&Element;</mo> <mi>W</mi> <mo>}</mo> <mo>,</mo> </mrow> </math> <math> <mrow> <mi>cod</mi> <mrow> <mo>(</mo> <mi>W</mi> <mo>)</mo> </mrow> <mo>=</mo> <mo>{</mo> <mi>y</mi> <mo>|</mo> <mo>&Exists;</mo> <mi>x</mi> <mo>:</mo> <mrow> <mo>(</mo> <mi>x</mi> <mo>,</mo> <mi>y</mi> <mo>)</mo> </mrow> <mo>&Element;</mo> <mi>W</mi> <mo>}</mo> <mo>;</mo> </mrow> </math>

in a quad, C is a limited set of clients; t is a limited set of tasks; w is a collection of jobs representing the division of work by the client in a task; d is a forwarding set and represents the circulation direction of the task;

(2) constructing a dynamic structure of the multi-step task cooperative network, namely a multi-step task cooperative network system, wherein an octave sigma ═ (C, T; W, D; W0, PD, G, L) is constructed according to the following conditions:

1 DEG N ═ C, T; W, D) is a multi-step mission collaborative net;

2°W₀w is a set of initial work, and the initial work refers to work which can be handled without depending on any task client;

3°P_Dis a set of forwarding conditions defined on D, a forwarding condition refers to a condition on which forwarding depends;

4G is a set of packets defined on C that need to be divided into a set, called packets, of jobs to be handled by the client and of the forwarding of the tasks to be delivered if there is a dependency between these jobs and the tasks completed;

a 5 ° L occlusal wye D, which is a set of cycles, a cycle refers to a circular path that can be executed repeatedly and retains only the last execution information;

(3) and constructing state sets required by multitask scheduling, wherein the state sets comprise five state sets:

state set for 1 ° case: si ═ Si_r，Si_w，Sw_fCases are executed once by the multi-step task collaborative network, and one multi-step task collaborative network can be executed for multiple times, wherein each execution corresponds to a different case, wherein,

Si_rready state: the case waits for the status of execution,

Si_win the office state: the state in which the case is executing,

Si_fand (4) completion state: a state where the case has ended;

set of states for 2 ° operation: sw ═ { Sw_r，Sw_w，Sw_n，Sw_fAnd (c) the step of (c) in which,

Sw_rready state: a state in which the job waits for the client to handle,

Sw_win the office state: the state in which work is being transacted by the client,

Sw_nnegative state: the work can not be handled by the client because the condition is not satisfied,

Sw_fand (4) completion state: a state where the work has ended;

state set for 3 ° task: st ═ St_r，St_w，St_n，St_fAnd (c) the step of (c) in which,

St_rready state: the task waits for the status of the client to transact,

St_win the office state: the state in which the task is being handled by the client,

St_nnegative state: the task is in a state of being unable to be handled by the client because the condition is not satisfied,

St_fand (4) completion state: a state in which the task has ended;

4 ° forwarded state set: sd ═ Sd_r，Sd_w，Sd_n，Sd_fAnd (c) the step of (c) in which,

Sd_rready state: forwarding the state waiting to be performed,

Sd_wa state to be signed: forwarding a shape waiting to be signed by a clientThe state of the optical disk is changed into a state,

Sd_nnegative state: forwarding a state that cannot be signed by the client because the condition is not satisfied,

Sd_fand (4) completion state: forwarding the state that has ended;

set of states for a 5 ° cycle: s1 ═ Sl_r，Sl_w，Sd_f}; wherein,

Sl_rready state: the loop waits for the state to be executed,

Sl_wthe working state is as follows: the state in which the loop is being executed,

Sl_fand (4) completion state: a state where the loop has ended;

(4) the multi-task scheduling comprises eight scheduling methods, namely a starting case, a terminating case, a client signing task, a client returning task, multi-step task handling, multi-step task reprocessing, starting circulation and terminating circulation; before multitask scheduling, cases and all work, tasks, forwarding, and loops are initialized to a ready state; the starting case is the first executed scheduling, the client signs a task, the client returns a task, multi-step tasks are handled, multi-step tasks are reworked, the starting cycle and the terminating cycle are scheduled by the client according to the flow direction of the multi-step task collaborative network, including the forward direction and the reverse direction, and the scheduling of the terminating case is automatically scheduled by the system according to the working and forwarding states;

order:

setstatus (x) indicates the state of a setting object x, x being a case, task, job, forward, or loop;

GetStatus (x) represents the state of an object x, wherein x is a case, a task, work, forwarding or circulation;

setclient (x) represents the client to which the set object belongs, and x is work or forwarding;

GetClient (x) represents the client to which the obtained object belongs, and x is work or forwarding;

precondition (x) represents condition calculation, the result is True or False, and x is forwarding;

count (x) represents the number of objects in a collection, x being a collection;

the scheduling method of the multi-step task can be expressed as follows:

1 ° start-up case:

let w₀For any initial job of case i, W₀Is w₀The scheduling method of the start case is as follows:

setting the status of the case and each of the initiatives to an in-office status, i.e.

SetStatus(i)：＝Si_w

SetStatus(w₀)：＝Sw_w，*w₀∈W₀

2 ° end case:

let W be any work of case i, W be the set of W, D be any forwarding of case i, and D be the set of D, then the scheduling method of the terminating case is:

the first step is as follows: if there are still jobs to be done or tasks to sign for, i.e. getstatus (w) ═ Sw_w， <math> <mrow> <mo>&Exists;</mo> <mi>w</mi> <mo>&Element;</mo> <mi>W</mi> </mrow> </math> Or GetStatus (d) ═ Sd_w， <math> <mrow> <mo>&Exists;</mo> <mi>d</mi> <mo>&Element;</mo> <mi>D</mi> <mo>,</mo> </mrow> </math> The case can not be terminated and the process is ended; otherwise, turning to the second step;

the second step is that: setting the state of the case to be a complete state, namely SetStatus (i): is Si ═ Si_f；

3 client sign-up tasks:

let c be any client in case i, g_cIs any packet defined on c, d is a packet g_cD is a set of D,'t is a task to which D belongs,dis any forwarding in the task't,Dis thatdIs any work in task't, ' W is a set of ' W, W is a packet g_cW is the set of W, t is the task to which W belongs,wis any one of the jobs in the task t,Wis thatwD' isIf any of the tasks t is forwarded and D 'is a set of D', the scheduling method for the client c to sign the tasks is as follows:

the first step is as follows: if g is_cIs in a pending or negative state, i.e., GetStatus (d) e { Sd_w，Sd_nThe * D belongs to D, then the second step is carried out; otherwise, ending;

the second step is that: if g is_cIs in a negative state, i.e. getstatus (d) ═ Sd_n* D belongs to D, then go to the third step; otherwise, turning to the fourth step;

the third step: g is prepared from_cIs set to a negative state, namely setstatus (w): sw_n* W ∈ W; for each w, if it belongs to each work of task twAre all in a negative state, i.e. GetStatus: (w)＝Sw_n,* w∈ WThen task t and each forwarding d' of task t are set to a negative state, i.e. setstatus (t): st-_nSetStatus(d′)：＝Sd_n* D 'is E.D', end; otherwise, ending;

the fourth step: for g_cIf it is in the ready state, set the client of d to c, i.e. setclient (d): if c, turning to the sixth step; otherwise, set the client of d to null, i.e., setclient (d): null, and go to the fifth step;

the fifth step: if the task't to which d belongs is in a negative state, namely GetStatus ('t): st-_nThen task't and each of its jobs' w and each of its forwardingsdSet to the done state, SetStatus ('t): st-_f，SetStatus(′w)：＝Sw_f，*′w∈′W，SetStatus( d)：＝Sd_f，* d∈ D；

And a sixth step: g is prepared from_cSet to completion status, set each work w to completion status, and set the client of each work w to c, setstatus (d): sd ═ Sd_f，*d∈D，SetClient(w)：＝c，*w∈W，SetStatus(w)：＝Sw_w* W ∈ W; if g is_cThe forwarding d is still in the pending or negative state, i.e. GetStatus (d) epsilon { Sd_w，Sd_nFourthly, * D belongs to D, then the fourth step is carried out; otherwise, turning to the seventh step;

the seventh step: if task t is ready, i.e. GetStatus (t) St_rThen task t is set to be in the office state, i.e., setstatus (t): st-_w；

Eighth step: client c transacts g_cAny one of the works w;

the ninth step: if the work w is done, the work w is set to a completion state, namely setstatus (w): sw_f(ii) a If g is_cStill has work in office, namely GetStatus (w) ═ Sw_w， <math> <mrow> <mo>&Exists;</mo> <mi>w</mi> <mo>&Element;</mo> <mi>W</mi> <mo>,</mo> </mrow> </math> Rotating to the eighth step; otherwise, ending;

4 client fallback task:

let c be any client in case i, g_cIs any packet defined on c, d is a packet g_cD is a set of D,'t is a task to which D belongs,dis any forwarding in the task't,Dis thatdIs any work in task't, ' W is a set of ' W, W is a packet g_cW is the set of W, t is the task to which W belongs,wis any one of the jobs in the task t,Wis thatwD is any forwarding in the task t, and D 'is a set of D', then the scheduling method for the client c to return to the task is as follows:

the first step is as follows: if g is_cIs in an on state, i.e. GetStatus (w) ═ Sw_w* W belongs to W, then the second step is carried out; otherwise, ending;

the second step is that: g is prepared from_cIs set to the ready state, setstatus (w): sw_r* W ∈ W; for g_cIf w belongs to each work of task twAre all in the ready state, i.e., GetStatus: (w)＝Sw_r，* w∈ WThen task t is set to the ready state, setstatus (t): st-_r；

The third step: for g_cIf the client is c, i.e., getclient (d) ═ c, then the client of d is set to null, and d is set to the to-be-signed state, i.e., setclient (d): null, setstatus (d): sd ═ Sd_wThen, turning to the fifth step; otherwise, set d to a negative state, i.e., setstatus (d): sd ═ Sd_nThen, turning to the fourth step;

the fourth step: if each forwarding of the task't to which d belongsdAre all in a negative state, i.e. GetStatus: (d)＝Sd_n，* d∈ DAnd each client working on ' W for task't is null, i.e. GetClient (' W) ═ null, * ' W ∈ ' W, then task't is set to the negative state, i.e. SetStatus ('t): st-_n(ii) a Finishing;

5 ° multi-step task handling:

let t be any task in the case, W be any work of task t, W be the set of W, c be the client responsible for handling work W, g_cIs any packet defined on client c, and'd is packet g_cIs a set of 'D,'t is a work to which 'D belongs,' W is any work of task't,' W is a set of 'W'dIs any forward of't'DIs'dThe set of (a) and (b),wis a packet g_cIn the above-mentioned manner, any one of the operations,Wis thatwD is any forwarding of the task t, D is the set of D, c' is the client to which D belongs, g_c'is any packet defined on client c',dis a packet g_cEither of the above-mentioned' forwarding is carried out,Dis thatdW' is a packet g_c'any work in W', W 'is a set of W', t 'is a task to which W' belongs,w'is any one of the jobs in the task t',W' isw' if D ' is any forwarding of t ' and D ' is a set of D ', the scheduling method of the task t handling process is as follows:

the first step is as follows: if every work w of task t is in the complete or negative state, i.e. GetStatus (w) e { Sw_f，Sw_n}， <math> <mrow> <munder> <mo>&ForAll;</mo> <mo>&CenterDot;</mo> </munder> <mi>w</mi> <mo>&Element;</mo> <mi>W</mi> <mo>,</mo> </mrow> </math> Then the second step is carried out; otherwise, ending;

the second step is that: if every task w of task t is in negative state, i.e. getstatus (w) Sw_n， <math> <mrow> <munder> <mo>&ForAll;</mo> <mo>&CenterDot;</mo> </munder> <mi>w</mi> <mo>&Element;</mo> <mi>W</mi> <mo>,</mo> </mrow> </math> Set task t and each forwarding d of task t to a negative state, setstatus (t): st-_n SetStatus(d)：＝Sd_n* D ∈ D, then go to the seventh step; otherwise, turning to the third step;

the third step: for any w in t, if w is in a negative state, then w is set to a complete state, the client of w is set to null, and w will be in the same group g as w_cEach of which operateswAnd each forwarding'd is set to a completion state, setstatus (w): sw_f，SetClient(w)：＝null，SetStatus( w)＝Sw_f，* w∈ W，SetStatus(′d)＝Sd_f* 'D ∈' D, then go to the fourth step; otherwise, turning to the fifth step;

the fourth step: for any'd, if the task't to which the'd belongs is in a negative state, i.e. GetStatus ('t) ═ St_nThen each of task't and task't is forwarded ' dSet to the done state, SetStatus ('t): st-_f，SetStatus(′ d)：＝Sd_f，*′ d∈′ D；

The fifth step: if task t has work w in negative state, i.e. GetStatus (w) ═ Sw_n， <math> <mrow> <mo>&Exists;</mo> <mi>w</mi> <mo>&Element;</mo> <mi>W</mi> <mo>,</mo> </mrow> </math> Turning to the third step; otherwise, turning to the sixth step;

and a sixth step: set task t to completion, i.e., setstatus (t): st-_f， <math> <mrow> <mo>&Exists;</mo> <mi>w</mi> <mo>&Element;</mo> <mi>W</mi> <mo>;</mo> </mrow> </math> Calculating a forwarding condition of each forwarding d of the task t, and if the result is True, namely precondition (d) True, setting the forwarding d to a to-be-signed state, namely setstatus (d): sd ═ Sd_w(ii) a Otherwise forward d is set to negative state, i.e. setstatus (d): sd ═ Sd_n；

The seventh step: for any d, if it belongs to the group g_cAll forwarding in `dIn the negative state, i.e. GetStatus: (d)＝Sd_n，* d∈ DThen group g will be grouped_cAll jobs in ' w ' are set to a negative state, i.e. SetStatus (w '): sw_n，*w′∈W′；

Eighth step: for any one w ', all jobs in task t' if it belongs tow' in a negative state, i.e. GetStatusS ((R))w′)＝Sw_n，* w′∈ W', then all forwarding d ' of task t ' and task t ' are set to negative state, i.e. SetStatus (t '): st-_n SetStatus(d′)＝Sd_n* D 'e.g. D'; finishing;

6 ° multi-step task rework:

let t be any task in the caseW is any work of task t, W is a set of W, c is the client responsible for handling work W, g_cIs any packet defined on client c, and'd is packet g_cIs a set of 'D,'t is a work to which 'D belongs,' W is any work of task't,' W is a set of 'W'dIs any forward of't'DIs'dThe set of (a) and (b),wis a packet g_cIn the above-mentioned manner, any one of the operations,Wis thatwD is any forwarding of the task t, D is the set of D, c' is the client to which D belongs, g_c'is any packet defined on client c',dis a packet g_cEither of the above-mentioned' forwarding is carried out,Dis thatdW' is a packet g_c'any work in W', W 'is a set of W', t 'is a task to which W' belongs,w'is any one of the jobs in the task t',W' isw' D ' is any forwarding of t ', D ' is a set of D ', then the scheduling method for client c to redo task t is as follows:

the first step is as follows: if task t is in the on-hold state, i.e., GetStatus (t) St_wOr task t is in completion and task t is not forwarded, i.e. getstatus (t) St_f &Count (d) 0, or task t is in complete state and each forwarding d of task t is in pending or negative state, i.e. getstatus (t) St_f & GetStatus(d)∈{Sd_w，Sd_nThe * D belongs to D, then the second step is carried out; otherwise, ending;

the second step is that: for any d, if it belongs to the group g_c' Each forwarding d in (a) is in a negative state, i.e. GetStatus: (d)＝Sd_n，* d∈ DThen group g will be grouped_cAll jobs w ' in ' are set to the ready state, SetStatus (w '): sw_r* W 'is belonged to W', and then the third step is carried out; otherwise, turning to the fourth step;

the third step: for any w ', if the task t' to which it belongs is in a negative state, each forwarding d 'of the task t' and the task t 'is set to a ready state, i.e. SetStatus (t') ═ St_r SetStatus(d′)＝Sd_r，*d′∈D′；

The fourth step: setting the task t and the work w to be reworked by the task t as an on-office state, and setting each forwarding d of the task t as a ready state, namely SetStatus (w): sw_w，SetStatus(t)：＝St_w，SetStatus(d)：＝Sd_r* D ∈ D; for any d, if it belongs to the group g_c' in which work w ' is in the negative state, i.e. GetStatus (w ') -Sw_n， <math> <mrow> <mo>&Exists;</mo> <msup> <mi>w</mi> <mo>&prime;</mo> </msup> <mo>&Element;</mo> <msup> <mi>W</mi> <mo>&prime;</mo> </msup> <mo>,</mo> </mrow> </math> Will group g_c' each work w ' in the set is set to the ready state, SetStatus (w '): sw_r，*w′∈W′；

The fifth step: if task t has work w in completion state and the client of w is null, i.e. getstatus (w) ═ Sw_f& GetClient(w)＝null， <math> <mrow> <mo>&Exists;</mo> <mi>w</mi> <mo>&Element;</mo> <mi>W</mi> <mo>,</mo> </mrow> </math> Set w to a negative state, setstatus (w): sw_n；

And a sixth step: for any one w in t, if w belongs to a group g_cEach of which operateswAre all in a negative state, i.e. GetStatus: (w)＝Sw_n，* w∈ WThen g is_cSet to a negative state, SetStatus ('d): sd ═ Sd_n，*′d∈′D；

The seventh step: for any'd, if its task't is in completion and the client of each work ' w of the task't is null, i.e. GetStatus ('t) ═ St_f &GetClient (' W) ═ null, * ' W ∈ ' W, then each job ' W of task't and task't is set to a negative state, SetStatus ('t): st-_n SetStatus(′w)：＝Sw_n，*′w∈′W；

Eighth step: client c reworks work w;

the ninth step: if the work w is done, the work w is set to a completion state, namely setstatus (w): sw_fAnd ending; otherwise, turning to the eighth step;

7 deg. start-up cycle:

let L be any cycle of case i, and w be any work on the cycle path, then the scheduling method of the start cycle is as follows:

if the work w belongs to the loop L and the work w is in the on-Do state and the loop L is in the ready state, i.e. w belongs to L&GetStatus(w)＝Sw_w & GetStatus(L)＝Sl_rThen set cycle L to run state, setstatus (L): sl ═ Sl_w(ii) a Otherwise, ending;

8 ° end cycle:

let L be any cycle of case i, and w be any work on the cycle path, then the scheduling method for terminating the cycle is as follows:

if the work w belongs to the loop L, the work w is in the on state and the loop L is in the running state, namely w belongs to the L&GetStatus(w)＝Sw_w& GetStatus(L)＝Sl_wThen set cycle L to run state, setstatus (L): sl ═ Sl_f(ii) a Otherwise, ending.

Images