Forking, joining and branching in modeling

In the UML activity diagram, a workflow is made of activities connected by transitions. The three primitives below control the flow.

Branching (decision and merge)

A branch is a diamond with one incoming flow and two or more outgoing flows, each guarded by a Boolean condition in square brackets. Exactly one outgoing flow is taken. A merge diamond brings alternative flows back together.

        [ Check Stock ]
              |
           < in stock? >
          [yes] /   \ [no]
     [Pack item]   [Order from supplier]
          \         /
           (merge)

Forking

A fork is a thick bar with one incoming flow and several outgoing flows. All outgoing flows are performed concurrently (in parallel).

Joining

A join is a thick bar that has several incoming flows and one outgoing flow. The outgoing flow proceeds only when all incoming flows have arrived (synchronisation).

        ( Order accepted )
               |
       ===================   fork
         |            |
  [Pack goods]   [Prepare invoice]
         |            |
       ===================   join
               |
         [ Dispatch ]

How they give the closest implementation model

• Branch maps directly to if / else and switch statements.
• Fork maps to starting threads or processes (new Thread(...).start()), and join to thread.join() or a barrier.
• A loop is a branch whose "no" flow returns to an earlier activity (while).
• Because activity diagrams use the same constructs as programs, an activity diagram can be converted almost one to one into code.

Sample (online order): Accept order -> branch on payment valid? -> if no, send rejection; if yes, fork into "pack goods" and "prepare invoice", join, then dispatch.

if (paymentValid) {
    Thread t1 = new Thread(() -> pack());
    Thread t2 = new Thread(() -> invoice());
    t1.start(); t2.start();      // fork
    t1.join();  t2.join();       // join
    dispatch();
} else { reject(); }