activiti学习（二十七）——涉及并行网关的节点跳转

最新推荐文章于 2024-01-10 07:00:00 发布
最新推荐文章于 2024-01-10 07:00:00 发布
阅读量2.7k 收藏 7
点赞数 1
分类专栏： Activiti
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sadoshi/article/details/107386804
版权

分析

关于并行任务的跳转，分享牛大神有他的代码。不过我觉得并行网关分支出来的任务，无论从现实业务还是逻辑实现上，都不应该可以随意跳转。

分享牛的跳转逻辑，无非是把并行分支的execution及其对应task都结束，然后跳转到目标节点上。然而这里其实涉及一些问题。从业务上来讲，某个分支流程，它自己是否要跳转到别的节点，不应该影响平行的其他任务节点，除非有明确的业务要求。从实现逻辑的角度来说，当存在多个并行网关多次分支的流程图中，跳转到某个节点时，到底需要提前结束哪些任务就会变得极难判断，如下图所示。综上所述，我认为并行网关中的任务不应该随意进行跳转。

实际业务可能不存在这样的流程，这里夸张了一点，纯粹举个例子。例如usertask6要跳转到usertask7，那根据图上来看，usertask5、usertask3的任务和execution必须删除。而且例如usertask4要跳转到usertask1，涉及的并行execution如何处理也是个问题。所以真不建议在并行网关中使用跳转。

只有一种情况的是可以进行跳转的，就是同一分支上的节点之间的跳转。例如下图这样：

usertask3跳转到usertask1，usertask2跳转到usertask6。类似这些在同一分支上的任务节点跳转，情况和普通的跳转类似，不过我们还是要对前面的例子改改

 

代码

这次我们的流程图如下，会有分支、以及多实例任务，我们计划是usertask1和usertask3之间可来回跳转，usertask2和usertask4也是如此：

<?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:activiti="http://activiti.org/bpmn" xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:omgdc="http://www.omg.org/spec/DD/20100524/DC" xmlns:omgdi="http://www.omg.org/spec/DD/20100524/DI" typeLanguage="http://www.w3.org/2001/XMLSchema" expressionLanguage="http://www.w3.org/1999/XPath" targetNamespace="http://www.activiti.org/test">
  <process id="parallelJump" name="parallelJump" isExecutable="true">
    <startEvent id="startevent1" name="Start"></startEvent>
    <parallelGateway id="parallelgateway1" name="Parallel Gateway"></parallelGateway>
    <sequenceFlow id="flow1" sourceRef="startevent1" targetRef="parallelgateway1"></sequenceFlow>
    <userTask id="usertask1" name="usertask1">
      <multiInstanceLoopCharacteristics isSequential="false">
        <loopCardinality>3</loopCardinality>
      </multiInstanceLoopCharacteristics>
    </userTask>
    <sequenceFlow id="flow2" sourceRef="parallelgateway1" targetRef="usertask1"></sequenceFlow>
    <userTask id="usertask2" name="usertask2"></userTask>
    <sequenceFlow id="flow3" sourceRef="parallelgateway1" targetRef="usertask2"></sequenceFlow>
    <userTask id="usertask3" name="usertask3"></userTask>
    <sequenceFlow id="flow4" sourceRef="usertask1" targetRef="usertask3"></sequenceFlow>
    <userTask id="usertask4" name="usertask4">
      <multiInstanceLoopCharacteristics isSequential="true">
        <loopCardinality>3</loopCardinality>
      </multiInstanceLoopCharacteristics>
    </userTask>
    <sequenceFlow id="flow5" sourceRef="usertask2" targetRef="usertask4"></sequenceFlow>
    <parallelGateway id="parallelgateway2" name="Parallel Gateway"></parallelGateway>
    <sequenceFlow id="flow6" sourceRef="usertask3" targetRef="parallelgateway2"></sequenceFlow>
    <sequenceFlow id="flow7" sourceRef="usertask4" targetRef="parallelgateway2"></sequenceFlow>
    <endEvent id="endevent1" name="End"></endEvent>
    <sequenceFlow id="flow8" sourceRef="parallelgateway2" targetRef="endevent1"></sequenceFlow>
  </process>
  <bpmndi:BPMNDiagram id="BPMNDiagram_parallelJump">
    <bpmndi:BPMNPlane bpmnElement="parallelJump" id="BPMNPlane_parallelJump">
      <bpmndi:BPMNShape bpmnElement="startevent1" id="BPMNShape_startevent1">
        <omgdc:Bounds height="35.0" width="35.0" x="110.0" y="250.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="parallelgateway1" id="BPMNShape_parallelgateway1">
        <omgdc:Bounds height="40.0" width="40.0" x="190.0" y="247.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="usertask1" id="BPMNShape_usertask1">
        <omgdc:Bounds height="55.0" width="105.0" x="250.0" y="180.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="usertask2" id="BPMNShape_usertask2">
        <omgdc:Bounds height="55.0" width="105.0" x="250.0" y="290.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="usertask3" id="BPMNShape_usertask3">
        <omgdc:Bounds height="55.0" width="105.0" x="410.0" y="180.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="usertask4" id="BPMNShape_usertask4">
        <omgdc:Bounds height="55.0" width="105.0" x="410.0" y="290.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="parallelgateway2" id="BPMNShape_parallelgateway2">
        <omgdc:Bounds height="40.0" width="40.0" x="540.0" y="247.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape bpmnElement="endevent1" id="BPMNShape_endevent1">
        <omgdc:Bounds height="35.0" width="35.0" x="625.0" y="250.0"></omgdc:Bounds>
      </bpmndi:BPMNShape>
      <bpmndi:BPMNEdge bpmnElement="flow1" id="BPMNEdge_flow1">
        <omgdi:waypoint x="145.0" y="267.0"></omgdi:waypoint>
        <omgdi:waypoint x="190.0" y="267.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow2" id="BPMNEdge_flow2">
        <omgdi:waypoint x="210.0" y="247.0"></omgdi:waypoint>
        <omgdi:waypoint x="210.0" y="207.0"></omgdi:waypoint>
        <omgdi:waypoint x="250.0" y="207.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow3" id="BPMNEdge_flow3">
        <omgdi:waypoint x="210.0" y="287.0"></omgdi:waypoint>
        <omgdi:waypoint x="210.0" y="317.0"></omgdi:waypoint>
        <omgdi:waypoint x="250.0" y="317.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow4" id="BPMNEdge_flow4">
        <omgdi:waypoint x="355.0" y="207.0"></omgdi:waypoint>
        <omgdi:waypoint x="410.0" y="207.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow5" id="BPMNEdge_flow5">
        <omgdi:waypoint x="355.0" y="317.0"></omgdi:waypoint>
        <omgdi:waypoint x="410.0" y="317.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow6" id="BPMNEdge_flow6">
        <omgdi:waypoint x="515.0" y="207.0"></omgdi:waypoint>
        <omgdi:waypoint x="560.0" y="207.0"></omgdi:waypoint>
        <omgdi:waypoint x="560.0" y="247.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow7" id="BPMNEdge_flow7">
        <omgdi:waypoint x="515.0" y="317.0"></omgdi:waypoint>
        <omgdi:waypoint x="560.0" y="317.0"></omgdi:waypoint>
        <omgdi:waypoint x="560.0" y="287.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge bpmnElement="flow8" id="BPMNEdge_flow8">
        <omgdi:waypoint x="580.0" y="267.0"></omgdi:waypoint>
        <omgdi:waypoint x="625.0" y="267.0"></omgdi:waypoint>
      </bpmndi:BPMNEdge>
    </bpmndi:BPMNPlane>
  </bpmndi:BPMNDiagram>
</definitions>

跳转的代码与前面MultiInstanceJumpCmd类似，但是要还要进行一些修改。之前我们是通过getProcessInstance获取其流程实例，进而获得其父execution，另外task也是与流程实例id关联的，通过流程实例id去控制是一种相对简便的处理方式。但在并行网关中，如果我们只处理单个分支的情况，通过流程实例id去处理task和execution，很可能会把另一分支也处理了，这不符合我们的预期，我们仅仅是需要处理当前分支对应的task和execution而已，所以不能通过流程实例id去操作，要老老实实根据活动节点的分类，判断是否获取其父节点进行操作：

package jump;

import java.util.List;
import java.util.Map;

import org.activiti.engine.delegate.TaskListener;
import org.activiti.engine.delegate.event.ActivitiEventType;
import org.activiti.engine.delegate.event.impl.ActivitiEventBuilder;
import org.activiti.engine.impl.bpmn.behavior.ParallelMultiInstanceBehavior;
import org.activiti.engine.impl.bpmn.behavior.SequentialMultiInstanceBehavior;
import org.activiti.engine.impl.context.Context;
import org.activiti.engine.impl.interceptor.Command;
import org.activiti.engine.impl.interceptor.CommandContext;
import org.activiti.engine.impl.persistence.entity.ExecutionEntity;
import org.activiti.engine.impl.persistence.entity.ExecutionEntityManager;
import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntity;
import org.activiti.engine.impl.persistence.entity.TaskEntity;
import org.activiti.engine.impl.persistence.entity.TaskEntityManager;
import org.activiti.engine.impl.pvm.process.ActivityImpl;
import org.activiti.engine.impl.pvm.runtime.AtomicOperation;
import org.activiti.engine.runtime.Execution;

public class ParallelJumpCmd implements Command {

	private String taskId;
	private Map<String, Object> variables;
	private String desActivityId;
	private String scActivityId;

	public ParallelJumpCmd(String taskId, Map<String, Object> variables, String scActivityId, String desActivityId) {
		this.taskId = taskId;
		this.variables = variables;
		this.desActivityId = desActivityId;
		this.scActivityId = scActivityId;
	}

	public Object execute(CommandContext commandContext) {
		TaskEntityManager taskEntityManager = commandContext.getTaskEntityManager();
		TaskEntity taskEntity = taskEntityManager.findTaskById(taskId);
		ExecutionEntity parentExecutionEntity = taskEntity.getProcessInstance();
		String processDefinitionId = parentExecutionEntity.getProcessDefinitionId();
		ProcessDefinitionEntity processDefinitionEntity = Context.getProcessEngineConfiguration().getDeploymentManager()
				.findDeployedProcessDefinitionById(processDefinitionId);
		ActivityImpl curActivityImpl = processDefinitionEntity.findActivity(scActivityId);

		if(curActivityImpl.getActivityBehavior() instanceof SequentialMultiInstanceBehavior) {
			parentExecutionEntity = taskEntity.getExecution().getParent();
		}else if(curActivityImpl.getActivityBehavior() instanceof ParallelMultiInstanceBehavior) {
			parentExecutionEntity = taskEntity.getExecution().getParent().getParent();
		}else {
			parentExecutionEntity = taskEntity.getExecution();
		}
		
		// 设置流程变量
		parentExecutionEntity.setVariables(variables);
		parentExecutionEntity.setExecutions(null);
		parentExecutionEntity.setActivity(curActivityImpl);
		parentExecutionEntity.setEventSource(curActivityImpl);
		parentExecutionEntity.setActive(true);

		// 触发全局事件转发器TASK_COMPLETED事件
		if (Context.getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
			Context.getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(ActivitiEventBuilder
					.createEntityWithVariablesEvent(ActivitiEventType.TASK_COMPLETED, this, variables, false));
		}

		// 删除任务
		List<ExecutionEntity> childExecutionEntityList = parentExecutionEntity.getExecutions();
		if(childExecutionEntityList.size() == 0) {
			//普通任务
			taskEntityManager.deleteTask(taskEntity, TaskEntity.DELETE_REASON_COMPLETED, false);	
		}
		for(ExecutionEntity childExecutionEntity : childExecutionEntityList) {
			List<ExecutionEntity> childExecutionEntityList1 = childExecutionEntity.getExecutions();
			if(childExecutionEntityList1.size() == 0) {
				//串行多实例任务处理
				List<TaskEntity> taskList = childExecutionEntity.getTasks();
				for(TaskEntity task : taskList) {
					task.fireEvent(TaskListener.EVENTNAME_COMPLETE);
					taskEntityManager.deleteTask(task, TaskEntity.DELETE_REASON_COMPLETED, false);	
				}
			}else {
				//并行多实例任务处理
				for(ExecutionEntity childExecutionEntity1 : childExecutionEntityList1) {
					List<TaskEntity> taskList1 = childExecutionEntity1.getTasks();
					for(TaskEntity task : taskList1) {
						task.fireEvent(TaskListener.EVENTNAME_COMPLETE);
						taskEntityManager.deleteTask(task, TaskEntity.DELETE_REASON_COMPLETED, false);	
					}
				}
			}
		}

		ExecutionEntityManager executionEntityManager = Context.getCommandContext().getExecutionEntityManager();
		List<ExecutionEntity> childExecutionList = executionEntityManager.findChildExecutionsByParentExecutionId(parentExecutionEntity.getId());
		for(ExecutionEntity executionEntityChild : childExecutionList) {
			List<ExecutionEntity> childExecutionList1 = executionEntityManager.findChildExecutionsByParentExecutionId(executionEntityChild.getId());
			for(ExecutionEntity executionEntityChild1 : childExecutionList1) {
				executionEntityChild1.remove();
				Context.getCommandContext().getHistoryManager().recordActivityEnd(executionEntityChild1);
			}
			executionEntityChild.remove();
			Context.getCommandContext().getHistoryManager().recordActivityEnd(executionEntityChild);
		}
		
		commandContext.getIdentityLinkEntityManager().deleteIdentityLinksByProcInstance(parentExecutionEntity.getId());
		ActivityImpl desActivityimpl = processDefinitionEntity.findActivity(desActivityId);	
		
		parentExecutionEntity.removeVariable("nrOfInstances");
		parentExecutionEntity.removeVariable("nrOfActiveInstances");
		parentExecutionEntity.removeVariable("nrOfCompletedInstances");
		parentExecutionEntity.removeVariable("loopCounter");
		
		parentExecutionEntity.setActivity(desActivityimpl);
		parentExecutionEntity.performOperation(AtomicOperation.TRANSITION_CREATE_SCOPE);

		return null;
	}
}

46-52行判断节点是串行多实例、并行多实例还是普通任务节点，分情况获取分支的父execution。68-92行也是分情况删除其execution下对应的task。如果还是像之前多实例任务跳转那样处理，就会把另一条分支上的task也删除了。另外59行要把状态设置成活动，因为多实例任务的父execution的isActive是false，跳转到普通任务节点，之后会导致普通任务节点的execution的usActive状态也是false，这就不对了。其他操作与前面的跳转是类似的，就不重复叙述了。

sadoshi
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
如何实现Activiti的分支条件的自定义配置
u013604967的博客
11-17 6178
一、Activiti的流程分支条件的局限 Activiti的流程分支条件目前是采用脚本判断方式，并且需要在流程定义中进行分支条件的设定，如下图所示：   &lt;sequenceFlow id="flow2" sourceRef="exclusiveGw" targetRef="theTask1"&gt; &lt;conditionExpression xsi:ty...
activiti并发多实例子流程任务处理
dkwrl82404的专栏
03-22 2874
一直在搞工作流(activiti)，总结一下关于工作流(activiti)中同时并发处理多个子流程的操作方法。 先说下我要实现的业务： 1、办公室发通知（在系统申报页面上，勾选科室，被选中的科室执行第二步） 2、科室科员填报数据 3、科室科长做审核（注意这里的科长审核是对应第二步的科室，本科科长去审核本单位填报完的任务） 4、办公室编制立项书，汇总数据 好，需求就先这样，这里...
activiti学习（二十二）——常规任务节点跳转（退回、自由跳转功能）
sadoshi的专栏
06-09 5513
概述 通过前面几篇文章的了解，目前我们已经具备足够的知识进行常规userTask的跳转。在“中国式流程”中，驳回、自由跳转等皆是通过这种改方式实现。可以说这也是玩activiti流程比较重要的一环。 activiti本身没有提供驳回和自由跳转的api，可能在老外的思维里，流程是不存在倒着走，或者随意跳转的，必须严格按照连线去走。我们必须通过自己手动去实现这样的功能。但是比较头疼的问题包括： 如果逐个调用实体管理类修改数据库记录，首先必须彻底摸透流程虚拟机执行情况以及流程运转时数据库变化情况，这个过于复
Activiti 学习笔记九：并行网关(parallelGateWay)
09-11
Activiti 学习笔记九：并行网关(parallelGateWay)
activitiy学习 (动态加签，动态流程图，指定节点跳转，指定多人节点跳转)
星空下的博客
02-15 4247
activitiy学习 (动态加签，动态流程图，指定节点跳转，指定多人节点跳转)
activiti学习（二十五）——多实例任务节点的跳转（退回、自由跳转功能）
sadoshi的专栏
07-05 4916
概述 相比普通任务节点跳转，多实例任务的跳转要考虑更多的因素，主要是因为多实例任务包含了父execution和子execution，子execution又有其对应的task，另外还有控制多实例任务的内置变量。这几个特殊点是处理多实例任务跳转的难点。关于普通节点跳转的处理，请参考前文《activiti学习（二十二）——常规任务节点跳转（退回、自由跳转功能）》 解决思路 ...
springboot+Activiti7整合实践 (七) 自定义用户任务行为
最新发布
刘一线的博客
01-10 2120
自定义UserTaskActivityBehavior用户任务活动行为类，设置工作流代办人
activiti 并行网关拆合过程中流程实例拆分情况分析
m0_59158906的博客
04-03 569
1. 并行网关定义 一个流程中流程实例只有一个，执行实例可以有多个； 并行网关的功能是基于进入和外出的顺序流提供的； 分支： 并行后的所有外出顺序流，为每个顺序流都创建一个并发分支； 汇聚： 所有到达并行网关，在此等待的进入分支，知道所有进入顺序流的分支都到达以后，流程就会通过汇聚网关。 并行网关的进入和外出都是使用相同的节点标识； 如果同一个并行网关有多个进入和多个外出顺序流，它就同时具有分支和汇聚功能。这时，网关会先汇聚所有进入的顺序流，然后再切分成多个并行分支。 并
activiti学习（二十八）——加签
sadoshi的专栏
07-28 9618
设计思路 加签本质上就是让多实例任务增加一个处理任务和新增处理人。实现其实很简单，无非是增加一个task，另外内置变量里的nrOfInstances、nrOfActiveInstances各加一。 实现
springboot整合Activiti-多实例任务串行并行配置
会走的鱼
08-31 1413
上面的程序已经解决了常用的问题，关于会签、加签、减签、退签、权重配置、自定义通过条件配置(条件自定义通过)< completionCondition > ${nrOfCompletedInstances/nrOfInstances >= 0.25} 完成条件的配置。
Android开发之activiti节点跳转
09-02
主要介绍了Android开发之activiti节点跳转的相关资料,需要的朋友可以参考下
activiti 7 + springboot2（十三）网关
01-19
activiti中有四种网关：并行网关，排他网关，包含网关，基于事件网关 排它网关： 内部是一个“X”图标，用来在流程中实现决策。 当流程执行到这个网关，所有外出顺序流都会被处理一遍。 其中条件解析为true的顺序...
Activiti 学习笔记十：开始活动节点（判断流程是否结束及查询历史）
09-11
Activiti 学习笔记十：开始活动节点（判断流程是否结束及查询历史）
activiti学习（五）——执行监听器与任务监听器的基本使用
热门推荐
sadoshi的专栏
03-09 1万+
本章先介绍监听器的基本原理和使用方法。当流程途径连线或者节点的时候，会触发对应的事件类型。监听器在生产中经常会用在几个方面： 动态分配节点处理人。通过前一个节点设置的变量，在运行到下一个节点时设置对应的处理人； 进行一些业务系统处理。例如发送邮件，或统计流程处理时长（公司按上班时间统计）、业务层面数据处理等等。 activiti监听器 activiti有两种监听器，分别是任务监听器和...
activiti学习（十一）——全局事件监听器的基本使用及其原理
sadoshi的专栏
04-04 7812
在流程运转的过程中，流程引擎会发出很多不同的事件，前面的文章，我们通过执行监听器和任务监听器捕获到对应事件并进行处理。除了这两个监听器以外，activiti从5.15版开始加入了全局事件监听器，这样就不需要在每个活动上去绑定监听器。 ...
activiti学习（十五）——表达式的使用
sadoshi的专栏
04-23 7446
本文开始重新回归一些activiti的基本使用。感觉前面太想展开源码和架构方面的探讨，但在这过程中，又涉及到activiti很多基本的用法我没有熟练使用，例如表达式、网关、多实例任务、作业、边界事件等等。导致在探讨源码的时候常常一笔带过，虽然对整体理解没有太大的问题，但是总感觉缺了点什么。所以后续决定也要熟练这些基本功能的使用。毕竟很多业务场景还是需要使用这些功能的。 表达式简述 activi...
activiti学习（六）——从bpmn文件转化为bpmnModel的过程
sadoshi的专栏
03-10 7403
在《activiti学习（二）——activiti流程的部署》一文中，提到过activiti会把bpmn文件转化成bpmnModel。本文对将这个过程做介绍。 我们从部署的实例入手，根据之前的部署命令deploymentBuilder.deploy()跟踪下去，查看DeploymentBuilderImpl.java： public Deployment deploy() { ret...
activiti学习（十七）——多实例任务的使用（会签功能）
sadoshi的专栏
05-07 7166
会签在中国式流程中是非常常见的需求。例如部门领导下发一个文件，需要部门里面每个员工看完之后提交流程以表示已阅。这时候需要使用activiti中的多实例任务。 ...
activiti学习（十六）——并行网关、排他网关、包含网关
sadoshi的专栏
05-01 6033
网关和分支是流程图中相当重要的一环。毕竟一个流程不可能是一条直线走到底的，可能需要并行处理，也可能需要根据条件的不同选择对应的路由，网关和分支的作用正是在此。本文主要探索一下这几种网关的常用方法，以及一些特殊情况会发生什么。 ...
activiti5.22 并行网关
07-28
Activiti 5.22版本中的并行网关是一种流程控制元素，用于在流程的不同分支上并行执行多个任务或活动。它允许流程在达到并行网关时分成多个分支，并在所有分支上同时执行任务，直到所有分支上的任务都完成后，流程才能继续向下执行。 在Activiti中，使用并行网关可以实现以下功能： 1. 并行执行多个任务：当流程到达并行网关时，它会创建多个分支，并在每个分支上同时执行相应的任务。这些任务可以是用户任务、服务任务或其他类型的活动。 2. 等待所有分支完成：并行网关会等待所有分支上的任务都完成后，才会将流程继续向下执行。如果某个分支上的任务还未完成，流程会一直等待。 3. 控制流程走向：并行网关可以根据条件来控制流程的走向。例如，可以设置一个条件，只有当所有分支的任务都完成时，流程才能继续向下执行。 要在Activiti 5.22中使用并行网关，可以在BPMN 2.0的流程图中添加一个并行网关元素，并将需要并行执行的任务或活动连接到该网关上。然后，通过设置相应的连线条件和任务完成条件来控制并行流程的走向和完成条件。 希望这个回答对你有帮助！如果你还有其他问题，请随时提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值