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

Abstract

The invention discloses a multi-task cooperative scheduling method for a workflow engine, and constructs a calculation model of the multi-task collaborative method—a multi-step task collaborative network, which is a quadruple N=(C, T; W, D ) is structured according to sufficient and necessary conditions, and multi-task scheduling includes eight scheduling methods: start case, terminate case, client sign-off task, client return task, multi-step task processing, multi-step task re-run, start cycle and terminate cycle. Cases and all jobs, tasks, forwards, loops are initialized to a ready state before multitasking is scheduled. The start-up case is the first to be executed and scheduled. The client signs the task, the client returns the task, the multi-step task processing, the multi-step task re-run, the start cycle and the termination cycle are based on the flow direction of the multi-step task collaboration network, including forward And conversely, the termination case scheduling is automatically scheduled by the system according to the status of work and forwarding. The invention realizes forward and reverse scheduling of multi-step tasks.

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 kind of multi-task cooperative scheduling method for workflow engine, it is characterized in that: carry out according to following steps: (i) Construct the computing model of the multi-task collaboration method—the multi-step task collaboration network, which is a quaternion N=(C, T; W, D) constructed according to the following sufficient and necessary conditions: 1°C≠φ 2°T≠φ 3°CI T＝φ 4°WC×T 5°DT×C 6°dom(W)Y cod(W)＝CYT in, $\mathrm{dom}\left(W\right)=\left\{x\right|\&Exists;\mathrm{the\; y}:(x,\mathrm{the\; y})\&Element;W\},$ $\mathrm{cod}\left(W\right)=\left\{\mathrm{the\; y}\right|\&Exists;x:(x,\mathrm{the\; y})\&Element;W\};$ In the quaternion, C is a limited set of clients; T is a limited set of tasks; W is a set of work, indicating the division of labor of clients in tasks; D is a set of forwarding, indicating the flow direction of tasks; (2) Build the dynamic structure of the multi-step task collaborative network—the multi-step task collaborative network system, which is an octet ∑=(C, T; W, D; W0, PD, G, L) constructed according to the following conditions of: 1°N=(C, T; W, D) is a multi-step task collaboration network; 2°W ₀ W is a collection of initial jobs, and initial jobs refer to jobs that can be handled without relying on any task client; 3°P _D is a set of forwarding conditions defined on D, and the forwarding conditions refer to the conditions on which forwarding depends; 4°G is a collection of groups defined in C. If there is a dependency relationship between the work to be done by the client and the completed tasks, it is necessary to divide these jobs and the forwarding of these tasks into a group, which is called a group; 5°LW∪D is a collection of loops, and loops refer to circular paths that can be executed repeatedly and only retain the last execution information; (3) Construct the state sets required for multi-task scheduling, including five state sets: 1° The state set of the case: Si={Si _r , Si _w , Sw _f }, the case is one execution of the multi-step task coordination network, a multi-step task coordination network can be executed multiple times, and each execution corresponds to a different case, where Si _r ready state: the state of the case waiting to be executed, Si _w running status: the status of the case being executed, Si _f completed state: the state that the case has ended; 2° working state set: Sw={Sw _r , Sw _w , Sw _n , Sw _f }, where, Sw _r ready state: the state that the work is waiting for the client to handle, Sw _w in-process state: the state that the work is being processed by the client, Sw _nNegative state: the state that the work cannot be handled by the client due to unsatisfied conditions, Sw _f completion state: the state that the work has ended; State set of 3° task: St={St _r , St _w , St _n , St _f }, where, _Str ready state: the state in which the task is waiting for the client to process, St _w in process status: the task is being processed by the client, St _n negative state: the state that the task cannot be processed by the client due to unsatisfied conditions, St _f completion state: the state that the task has ended; 4°Forwarding state set: Sd={Sd _r , Sd _w , Sd _n , Sd _f }, where, Sd _r ready state: the state of forwarding waiting to be executed, Sd _w to be signed status: the status of forwarding waiting to be signed by the client, Sd _n Negative state: the state that the forwarding cannot be signed by the client due to unsatisfied conditions, Sd _f completion state: the state that forwarding has ended; State set of 5° cycle: S1={Sl _r , Sl _w , Sd _f }; where, Sl _r ready state: the state of the loop waiting to be executed, Sl _w working state: the state that the loop is being executed, Sl _f completion state: the state that the cycle has ended; (4) Multi-task scheduling includes eight scheduling methods: start case, terminate case, client signed task, client return task, multi-step task processing, multi-step task re-run, start cycle and terminate cycle; before multi-task scheduling , the case and all jobs, tasks, forwarding, and loops are initialized to the ready state; the startup case is the first to be executed and scheduled, the client signs the task, the client returns the task, multi-step task processing, and multi-step task re-running , The start cycle and the termination cycle are scheduled by the client according to the flow direction of the multi-step task collaboration network, including forward and reverse, and the scheduling of the termination case is automatically scheduled by the system according to the status of work and forwarding; make: SetStatus(x) means setting the status of object x, where x is case, task, work, forwarding or circulation; GetStatus(x) means to obtain the status of object x, where x is case, task, work, forwarding or circulation; SetClient(x) means setting the client to which the object belongs, and x is work or forwarding; GetClient(x) means to obtain the client to which the object belongs, and x is work or forwarding; PreCondition(x) means condition calculation, the result is True or False, x is forwarding; Count(x) indicates the number of objects in the collection, x is a collection; Then the scheduling method of multi-step tasks can be expressed as follows: 1° startup case: Let w ₀ be any initial work of case i, W ₀ is the set of w ₀ , then the scheduling method of the start case is as follows: Set the status of the case and each initiated job to Open, i.e. SetStatus(i):=Si _w SetStatus(w ₀ ):=Sw _w , w ₀ ∈W ₀ 2° Termination case: Suppose w is any job of case i, W is the set of w, d is any forwarding of case i, and D is the set of d, then the scheduling method for terminating the case is: Step 1: If there is still work to be done or task to be signed in the case, ie GetStatus(w)=Sw _w , $\&Exists;w\&Element;W$ or GetStatus(d)=Sd _w , $\&Exists;d\&Element;\mathrm{D.},$ If the case cannot be terminated, end; otherwise, go to the second step; The second step: the state of the case is set to the complete state, that is, SetStatus(i):=Si _f ; 3°Client signing tasks: Let c be any client in case i, g _c be any group defined on c, d be any forwarding in group g _c , D be the set of d, 't be the task to which d belongs, d is any forwarding in task 't, D is the set of d , 'w is any work in task 't, 'W is the set of 'w, w is any work in group g _c , W is w , t is the task to which w belongs, w is any job in task t, W is the set of w , d' is any forwarding in task t, D' is the set of d', then client c signs The method of scheduling tasks is as follows: Step 1: If each forwarding d in g _c is pending or negated, that is, GetStatus(d)∈{Sd _w , Sd _n }, d∈D, go to the second step; otherwise, end; The second step: if each forwarding d in g _c is in a negative state, that is, GetStatus(d)=Sd _n , d∈D, then go to the third step; otherwise, go to the fourth step; Step 3: Set each work w in g _c to a negative state, that is, SetStatus(w):=Sw _n , w∈W; for each w, if each work w of the task t it belongs to is in Negative status, that is, GetStatus( w )=Sw _n , w ∈ W , then set task t and each forwarding d′ of task t to negative status, that is, SetStatus(t):=St _n SetStatus(d′): =Sd _n , d′∈D′, end; otherwise end; The fourth step: for any d in g _c , if it is in the state to be signed, the client of d is set to c, that is, SetCliet(d):=c, then turn to the sixth step; otherwise, the client of d Machine is set to null value null, namely SetClient(d):=null, and turn to the fifth step; Step 5: If the task 't to which d belongs is in a negative state, that is, GetStatus('t):=St _n , then set the task 't, each work'w and each forwarding d to a completed state, that is, SetStatus( ′t):=St _f , SetStatus(′w):=Sw _f , ′w∈′W, SetStatus( d ):=Sd _f , d ∈ D ; The sixth step: each forwarding d in g _c is set to complete state, each work w is set to complete state, and the client of each work w is set to c, that is, SetStatus(d):=Sd _f , d∈D, SetClient(w):=c, w∈W, SetStatus(w):=Sw _w ,w∈W; if g _c still forwards d in pending or negative state, that is, GetStatus( d)∈{Sd _w , Sd _n }, d∈D, then go to the fourth step; otherwise, go to the seventh step; Step 7: If the task t is in the ready state, that is, GetStatus(t)= _Str , then set the task t to the in-process state, that is, SetStatus(t):=St _w ; Step 8: client c handles any job w in g _c ; Step 9: If the job w is completed, set the job w to the completed state, that is, SetStatus(w):=Sw _f ; if there are still jobs in the processing state in g _c , that is, GetStatus(w)=Sw _w , $\&Exists;w\&Element;W,$ Then turn to the eighth step; otherwise end; 4 ° The client returns the task: Let c be any client in case i, g _c be any group defined on c, d be any forwarding in group g _c , D be the set of d, 't be the task to which d belongs, d is any forwarding in task 't, D is the set of d , 'w is any work in task 't, 'W is the set of 'w, w is any work in group g _c , W is w , t is the task to which w belongs, w is any job in task t, W is the set of w , d is any forwarding in task t, D' is the set of d', then client c returns the task The scheduling method is as follows: The first step: if every job w in g _c is in the processing state, that is, GetStatus(w)=Sw _w , w∈W, then go to the second step; otherwise, end; Step 2: Set each work w in g _c to the ready state, that is, SetStatus(w):=Sw _r , w∈W; for each work w in g _c , if w belongs to task t Every work w is in the ready state, that is, GetStatus( w )=Sw _r ,  w ∈ W , then set the task t to the ready state, that is, SetStatus(t):=St _r ; The third step: for any d in g _c , if its client is c, i.e. GetClient(d)=c, then the client computer of d is set to null, and d is set to the state to be signed, i.e. SetClient( d):=null, SetStatus(d):=Sd _w , then turn to the fifth step; otherwise d is set to a negative state, that is, SetStatus(d):=Sd _n , then turn to the fourth step; Step 4: If every forwarding d of task 't to which d belongs is in a negative state, that is, GetStatus( d )=Sd _n ,  d ∈ D , and every client of task 't'w is empty Value null, i.e. GetClient ('w)=null, 'w∈'W, then task 't is set to a negative state, i.e. SetStatus ('t):=St _n ; end; 5° multi-step task processing: Suppose t is any task in the case, w is any job of task t, W is the set of w, c is the client responsible for handling job w, g _c is any group defined on client c,' d is any forwarding in group g _c , 'D is the set of 'd, 't is the job to which 'd belongs, 'w is any job of task 't, 'W is the set of 'w,' d is Any forwarding of 't,' D is the set of ' d , w is any job in group g _c , W is the set of w , d is any forwarding of task t, D is the set of d, c' is The client to which d belongs, g _c ' is any group defined on client c', d is any forwarding in group g _c ', D is the set of d , w' is any group in group g _c ' A job, W' is the set of w', t' is the task to which w' belongs, w ' is any job in the task t', W ' is the set of w ', d' is any forwarding of t', D' is the set of d', then the scheduling method of task t handling process is as follows: Step 1: If each work w of task t is in the completed or negative state, that is, GetStatus(w)∈{Sw _f , Sw _n }, $\underset{\&CenterDot;}{\&ForAll;}w\&Element;W,$ Then turn to the second step; otherwise end; Step 2: If every job w of task t is in negative state, ie GetStatus(w)= _Swn , $\underset{\&CenterDot;}{\&ForAll;}w\&Element;W,$ Then set task t and each forwarding d of task t to a negative state, that is, SetStatus(t):=St _n SetStatus(d):=Sd _n , d∈D, then go to the seventh step; otherwise go to the third step step; Step 3: For any w in t, if w is in the negative state, set w to complete state, set the client of w to null value, and set each job in the same group g _c as w w and each forwarding 'd are set to complete status, that is, 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 go to the fifth step; Step 4: For any 'd, if the task 't to which 'd belongs is in a negative state, that is, GetStatus('t)=St _n , then set task 't and each forwarding ' d of task 't to the completed state , namely SetStatus(′t):=St _f , SetStatus(′ d ):=Sd _f , ′ d ∈′ D ; Step 5: If task t has work w in negative state, ie GetStatus(w)= _Swn , $\&Exists;w\&Element;W,$ Then go to the third step; otherwise go to the sixth step; Step 6: Set task t to complete status, namely SetStatus(t):=St _f , $\&Exists;w\&Element;W;$ Calculate the forwarding condition of each forwarding d of task t, if the result is true, that is, PreCondition(d)=True, then forwarding d is set to be signed, that is, SetStatus(d):=Sd _w ; otherwise, forwarding d is set It is a negative state, that is, SetStatus(d):=Sd _n ; Step 7: For any d, if all the forwarding d in the group g _c ' to which it belongs are in the negative state, that is, GetStatus( d )=Sd _n ,  d ∈ D , then all the work w in the group g _c ''Set as a negative state, that is, SetStatus(w'):=Sw _n , w'∈W'; Step 8: For any w′, if all the tasks w ′ in the task t′ to which it belongs are in the negative state, that is, GetStatusS( w ′)= _Swn ,  w ′∈ W ′, then combine task t′ and task All forwarding d' of t' are set to negative status, that is, SetStatus(t'):=St _n SetStatus(d')=Sd _n , d'∈D';end; 6° multi-step task redo: Suppose t is any task in the case, w is any job of task t, W is the set of w, c is the client responsible for handling job w, g _c is any group defined on client c,' d is any forwarding in group g _c , 'D is the set of 'd, 't is the job to which 'd belongs, 'w is any job of task 't, 'W is the set of 'w,' d is Any forwarding of 't,' D is the set of ' d , w is any job in group g _c , W is the set of w , d is any forwarding of task t, D is the set of d, c' is The client to which d belongs, g _c ' is any group defined on client c', d is any forwarding in group g _c ', D is the set of d , w' is any group in group g _c ' A job, W' is the set of w', t' is the task to which w' belongs, w ' is any job in the task t', W ' is the set of w ', d' is any forwarding of t', D' is the set of d', then the scheduling method of client c rerunning task t is as follows: Step 1: If the task t is in the running state, that is, GetStatus(t)=St _w , or the task t is in the completed state and the task t has not been forwarded, that is, GetStatus(t)=St _f & Count(D)=0, or Task t is in the completed state and each forwarding d of task t is in pending or negative state, that is, GetStatus(t)=St _f & GetStatus(d)∈{Sd _w , Sd _n }, d∈D, then turn to Step 2; otherwise end; Step 2: For any d, if each forwarding d in the group g _c ' to which it belongs is in a negative state, that is, GetStatus( d )=Sd _n ,  d ∈ D , then all the forwarding d in the group g _c ' Work w'is set to the ready state, that is, SetStatus(w'):=Sw _r , w'∈W', then go to the third step; otherwise go to the fourth step; Step 3: For any w', if the task t' to which it belongs is in the negative state, then set the task t' and each forwarding d' of the task t' to the ready state, that is, SetStatus(t')= _Str SetStatus (d')=Sd _r , d'∈D'; Step 4: Set task t and the task w to be re-done by task t to the ongoing state, and set each forwarding d of task t to the ready state, that is, SetStatus(w):=Sw _w , SetStatus(t) :=St _w , SetStatus(d):=Sd _r , d∈D; for any d, if there is a job w'in the negative state in the group g _c ' to which it belongs, that is, GetStatus(w')=Sw _n , $\&Exists;w^{\&prime;}\&Element;W^{\&prime;},$ Then set each work w' in the group g _c ' to the ready state, that is, SetStatus(w'):=Sw _r ,w'∈W'; Step 5: If task t has work w in completion state, and the client of w is null, that is, GetStatus(w)=Sw _f & GetClient(w)=null, $\&Exists;w\&Element;W,$ Then set w to a negative state, that is, SetStatus(w):=Sw _n ; Step 6: For any w in t, if every work w in the group g _c to which w belongs is in a negative state, that is, GetStatus( w )= _Swn ,  w ∈ W , then each work w in g _c A forwarding 'd is set to a negative state, that is, SetStatus('d):=Sd _n , 'd∈'D; Step 7: For any 'd, if the task 't to which it belongs is in the completed state, and the client of each work 'w of the task 't is null, that is, GetStatus('t)=St _f & GetClient ('w)=null, 'w∈'W, then set task 't and each task 'w of task 't to a negative state, that is, SetStatus('t):=St _n SetStatus('w) :=Sw _n ,′w∈′W; The eighth step: the client c reruns the work w; The ninth step: if the work w is completed, set the work w to the completed state, that is, SetStatus(w):=Sw _f , end; otherwise, go to the eighth step; 7° start cycle: Let L be any cycle of case i, and w be any job on the cycle path, then the scheduling method to start the cycle is as follows: If the work w belongs to the cycle L and the work w is in the running state and the cycle L is in the ready state, that is, w∈L &GetStatus(w)=Sw _w & GetStatus(L)=Sl _r , then set the cycle L to the running state, that is SetStatus(L):=Sl _w ; otherwise end; 8° terminated loop: Let L be any cycle of case i, and w be any job on the cycle path, then the scheduling method for terminating the cycle is as follows: If the work w belongs to the cycle L and the work w is in the running state and the cycle L is in the running state, that is, w∈L&GetStatus(w)=Sw _w & GetStatus(L)=Sl _w , then set the cycle L to the running state, that is, SetStatus (L): = Sl _f ; otherwise end.

Images