Pregunta a tres personas cómo avanza un pedido por tu empresa y es posible que obtengas tres respuestas. Una dice que la factura sale antes de empaquetar, otra que después del envío, y nadie sabe qué ocurre cuando un artículo no tiene stock. Un diagrama de flujo en la pizarra ayuda hasta que dos cosas pasan a la vez y las flechas sugieren un orden que no existe.
Un diagrama de actividad UML está hecho para esto: pasos, decisiones, trabajo en paralelo y quién hace cada parte. Esta entrada construye un ejemplo de procesamiento de pedidos pieza por pieza, con una guía de símbolos, las reglas de tokens que lo sustentan, errores comunes y una comparación de los diagramas de actividad con los diagramas de flujo, BPMN y los diagramas de estados.
Qué muestra un diagrama de actividad
Un diagrama de actividad muestra un comportamiento como acciones conectadas por flujos. Las reglas provienen de la especificación UML 2.5.1, publicada por el Object Management Group (OMG) en diciembre de 2017 y todavía la versión formal vigente en el momento de escribir esto (noviembre de 2026). El capítulo 15 (Activities) y el capítulo 16 (Actions) definen la notación.
Úsalo cuando la pregunta sea el orden del trabajo: un proceso de negocio que cruza equipos, el escenario detrás de un caso de uso o un pipeline con ramas y etapas en paralelo. Usa una máquina de estados cuando la pregunta sea en qué estado está un pedido, un diagrama de secuencia cuando sea qué servicio llama a cuál, y un diagrama de clases cuando sea cómo se estructuran los datos.
Símbolos del diagrama de actividad
UML reutiliza dos formas para cuatro nodos de control: la decisión y el merge son rombos, y el fork y el join son barras. Cuenta los flujos de entrada y de salida para distinguirlos.
| Símbolo | Aspecto | Qué significa |
|---|---|---|
| Nodo inicial | Círculo pequeño relleno | Donde empieza el flujo |
| Acción | Rectángulo redondeado con una frase verbal | Un paso de trabajo |
| Flujo de control | Flecha, opcionalmente con una [guarda] | Orden de ejecución |
| Nodo de decisión | Rombo, un flujo de entrada, varios de salida | Envía cada token por un único camino, elegido por las guardas |
| Nodo merge | Rombo, varios flujos de entrada, uno de salida | Combina caminos alternativos sin esperar |
| Nodo fork | Barra, un flujo de entrada, varios de salida | Inicia todos los flujos de salida de forma concurrente |
| Nodo join | Barra, varios flujos de entrada, uno de salida | Espera a todos los flujos de entrada y luego continúa |
| Fin de actividad | Diana: círculo relleno dentro de un anillo | Termina toda la actividad |
| Fin de flujo | Círculo con una X | Termina solo el flujo que llega a él |
| Nodo de objeto | Rectángulo con un sustantivo, o un pin en una acción | Datos que pasan entre acciones |
| Partición | Calle con nombre en un extremo | Agrupa las acciones de un participante |
En la especificación, fork y join son «simplemente un segmento de línea»; las herramientas lo engrosan hasta formar una barra. La especificación también señala que las particiones son «coloquialmente conocidas como» calles (swimlanes).
Cómo se mueven los tokens por el diagrama
UML define estos símbolos con tokens, como fichas en un tablero de juego. Cuando empieza la actividad, un token de control está en el nodo inicial. Una acción se ejecuta cuando cada flujo de entrada le ofrece un token, y luego ofrece un token en cada flujo de salida. Una decisión envía cada token por como máximo un flujo de salida, el de la guarda verdadera; un merge deja pasar cada token directamente; un fork copia el token en todos los flujos de salida; un join espera a que cada flujo de entrada ofrezca un token y entonces emite uno. El primer token que llega a un nodo de fin de actividad termina la actividad, incluido todo lo que siga en ejecución.
Dos consecuencias sorprenden a quien aprendió primero los diagramas de flujo:
- Dos flechas que entran en una acción significan esperar a ambas, un join implícito. Si las flechas vienen de las dos ramas de una decisión, solo una lleva un token y la acción nunca arranca. Los caminos alternativos deben reunirse antes en un merge.
- Dos flechas que salen de una acción significan hacer ambas, un fork implícito. Es legal, pero los lectores lo pasan por alto; dibuja mejor una barra fork.
Construir el ejemplo paso a paso
- Dibuja primero las particiones: Customer, Warehouse y Billing. Las calles obligan a plantear pronto las preguntas de responsabilidad.
- Inicia el flujo. Un nodo inicial en la calle Customer conduce a Place order.
- Añade la decisión. En la calle Warehouse, una decisión comprueba el stock, con las guardas [in stock] y [out of stock]. Las guardas deben excluirse entre sí y cubrir todos los casos; la guarda predefinida [else] de UML recoge el resto.
- Haz el merge de los caminos. Los pedidos sin stock pasan por Backorder items, y luego ambos caminos se reúnen en un merge. El merge es obligatorio: un fork acepta exactamente un flujo de entrada, y una acción con dos flujos de entrada esperaría a ambos.
- Haz un fork del trabajo en paralelo. Una barra fork inicia Pack items (Warehouse) y Create invoice (Billing). Concurrente significa que ninguno espera al otro, no que se ejecuten en el mismo instante.
- Haz un join antes del envío. Una barra join espera a que ambos terminen; solo entonces se ejecuta Ship order.
- Termina la actividad. Un nodo de fin de actividad sigue a Ship order. Los nodos de control no son trabajo, así que pueden estar en cualquier calle; este está en la calle Customer, justo encima de Ship order.
En PlantUML, el mismo flujo es texto plano: |Customer| para las calles, if, else y endif para las decisiones, y fork, fork again y end fork para el trabajo en paralelo. El diseño es automático, así que cambias control por velocidad.
Errores comunes
| Error | Qué sale mal | Solución |
|---|---|---|
| Un fork sin join | La primera rama que llega al fin de actividad termina la actividad y detiene a la otra | Hacer un join de las ramas, o terminar cada una con un fin de flujo |
| Una decisión para trabajo en paralelo | Solo se ejecuta una rama | Usar una barra fork |
| Un merge donde hace falta un join | La siguiente acción puede ejecutarse dos veces, una por token | Usar una barra join |
| Un join después de una decisión | Solo una rama lleva un token, así que el join espera para siempre | Usar un rombo merge |
| Guardas sin etiqueta o que se solapan | Los lectores adivinan; UML deja sin definir el orden de evaluación de las guardas | Guardas que se excluyan entre sí, más [else] |
| Nombres de acción vagos | Procesamiento no dice nada del trabajo | Un verbo y un objeto: Pack items |
La tercera y la cuarta fila son imágenes especulares: un merge nunca espera, y un join puede esperar para siempre. Antes de compartir un diagrama, sigue un token por cada rama.
Diagramas de actividad, diagramas de flujo, BPMN y diagramas de estados
| Diagrama de actividad | Diagrama de flujo | BPMN | Diagrama de máquina de estados | |
|---|---|---|---|---|
| Muestra | Pasos de un comportamiento, con datos y trabajo en paralelo | Pasos y decisiones | Procesos entre participantes, con eventos y mensajes | Los estados de un objeto y los eventos que los cambian |
| Trabajo en paralelo | Barras fork y join | Sin símbolo en el conjunto habitual | Gateway paralelo | Regiones ortogonales |
| Quién hace qué | Particiones (calles) | Calles en diagramas de flujo interfuncionales | Pools y lanes | No se muestra |
| Estándar | UML 2.5.1 (OMG) | ISO 5807 (1985), seguido con flexibilidad | BPMN 2.0.2 (OMG) | UML 2.5.1 (OMG) |
| Ideal para | Comportamiento de software, flujos de casos de uso, pipelines | Bocetos rápidos para cualquier público | Automatización de procesos, flujos entre organizaciones | Ciclos de vida de pedidos o suscripciones |
Los diagramas de actividad y BPMN son primos: ambos definen el comportamiento con tokens, y BPMN 2.0.2 también especifica una semántica de ejecución para motores de procesos. Elige BPMN para procesos ejecutables y mensajes entre organizaciones (consulta el ejemplo de diagrama BPMN), una máquina de estados para el ciclo de vida de un objeto (consulta el ejemplo de diagrama de estados), un diagrama de flujo para lectores que nunca aprenderán UML, y un diagrama de actividad cuando importan el trabajo en paralelo y la precisión del significado.
El diagrama de actividad del procesamiento de pedidos
Contenido del diagrama
- Customer
- Warehouse
- Billing
- Place order
- In stock?
- Backorder items
- Pack items
- Ship order
- Create invoice
- [in stock]
- [out of stock]
Cómo leerlo:
- Tres calles: Customer, Warehouse y Billing, cada una con sus propias acciones.
- Empieza en el círculo relleno: el cliente hace el pedido y el flujo baja a la calle Warehouse.
- La decisión In stock? tiene dos salidas con guarda: [in stock] va al merge, [out of stock] da un rodeo por Backorder items, en naranja. Las marcas Y y N son los marcadores de salida integrados del editor; las guardas son las que llevan el significado UML.
- El rombo pequeño es el merge donde ambos caminos se vuelven a unir.
- La primera barra es el fork que inicia Pack items y Create invoice; la segunda es el join que hace que Ship order espere a ambos.
- La diana sobre Ship order termina la actividad, y la tabla bajo las calles repite la regla de tokens de cada nodo de control.
Dibujar diagramas de actividad con claridad
- Elige una dirección. Las calles horizontales con flujo de izquierda a derecha encajan en páginas anchas; las calles verticales con flujo hacia abajo, en procesos largos.
- Nombra las acciones con un verbo y un objeto: Pack items, Create invoice. Una acción que necesita un párrafo es una subactividad; dibújala como una acción de llamada a comportamiento, marcada con el pequeño símbolo de rastrillo de UML, y detállala en su propio diagrama.
- Pon las guardas en los flujos. Una pregunta dentro del rombo ayuda a los lectores, pero las guardas entre corchetes llevan el significado.
- Dibuja cada merge y cada join. Los joins y forks implícitos son legales pero invisibles.
- Mantén pocas calles. De tres a cinco siguen siendo legibles; con ocho, divide el proceso.
- Deja fuera lo que no cambia el flujo, como el registro de logs o los reintentos dentro de un paso, y añade nodos de objeto solo cuando los datos importan.
Para calles sin el resto de UML, consulta el ejemplo de diagrama de calles.
Constrúyelo en Archboard
- Inicia sesión con Google o GitHub y crea un diagrama.
- Añade tres nodos Marco del paquete Básico como calles horizontales: Customer, Warehouse y Billing.
- Añade una Elipse pequeña del paquete Básico con relleno oscuro como nodo inicial.
- Añade cinco nodos Proceso del paquete Diagrama de flujo en sus calles: Place order, Backorder items, Pack items, Create invoice y Ship order.
- Añade un nodo Decisión del paquete Diagrama de flujo con la etiqueta In stock?, y un Rombo pequeño del paquete Básico para el merge. Etiqueta las salidas [in stock] y [out of stock].
- Para el fork y el join, añade dos nodos Cuadrado finos y altos del paquete Básico con relleno oscuro.
- Para el fin de actividad, añade un Icono del paquete Básico con el icono record-circle-outline, un punto dentro de un anillo.
- Conecta los nodos y luego añade dos anotaciones Texto de Básico y un bloque Markdown del paquete Básico con la tabla de la leyenda.
Si el flujo existe como diagrama de flujo de Mermaid, la herramienta de Mermaid a diagrama te da un primer borrador editable para afinar con estos nodos. Para un diagrama de flujo sencillo con calles, empieza con el creador de diagramas de flujo.
El ejemplo usa 15 nodos de diagrama, dentro del plan Free.
Preguntas frecuentes
¿Qué es un diagrama de actividad en UML? Un diagrama de comportamiento que muestra un proceso como acciones conectadas por flujos, con decisiones, fork y join para el trabajo en paralelo, y calles para indicar quién hace qué. UML 2.5.1 lo define en el capítulo 15.
¿Cuál es la diferencia entre un fork y una decisión? Una decisión envía cada token por un solo flujo de salida, elegido por las guardas. Un fork envía una copia por cada flujo de salida, así que las ramas se ejecutan de forma concurrente. Las decisiones son rombos; los forks son barras.
¿Cuál es la diferencia entre un fin de actividad y un fin de flujo? Un fin de actividad, una diana, termina toda la actividad y todos los flujos que contiene. Un fin de flujo, un círculo con una X, termina solo el flujo que llega a él.
¿Cómo funcionan las calles en un diagrama de actividad? Las calles son particiones de actividad de UML. Cada calle agrupa las acciones de una persona, un equipo o un sistema; los flujos cruzan las calles libremente, y las calles no cambian cómo se mueven los tokens.
¿Es lo mismo un diagrama de actividad que un diagrama de flujo? No, aunque se parezcan. Los diagramas de actividad añaden fork y join, nodos de objeto para los datos, particiones y reglas de tokens que dan a cada símbolo un significado preciso.