In computer science, multitasking means the support in the execution of multiple flows of execution at the same time (in a "parallel" way). In systems with severe memory constraints such as computers based on 8 bit processors, this cannot be obtained using traditional techniques, because it takes too much memory since each parallel process requires its own stack which, in turn, occupies large parts of the available memory.

For this reason a mechanism based on protothreads has been implemented. This mechanism makes it possible to define procedures that will be executed for appropriate “quanta” of time, without however the execution being interrupted unexpectedly.

Now let's try to write down the following example program, and run it.

PARALLEL PROCEDURE example1
   DO
      PRINT "example"
   LOOP
END PROC

SPAWN example

If you compile the source code with ugBASIC v1.14.1 or less, you can notice that, on the screen, you will see nothing. Why? Because the SPAWN command will prepare only the system to run the procedure in a parallel fashion. You need to decide when this will occour in your main program.

The command to use to invoke a “multitasking slice” is RUN PARALLEL. Whenever that command is invoked, all the procedures registered to run in parallel mode are executed in the same “slice” of time. In order to make “permanent” execution of the various programs in parallel, you need to place the call inside a DO...LOOP.

For example, this is a very simple example. We will run two separates tasks: the first will print the “example” string, while the second will print the “example2”. Since the two tasks are running at the very same time on the processor, the two strings are printed alternatively.

PARALLEL PROCEDURE example1
   DO
      PRINT "example"
   LOOP
END PROC

PARALLEL PROCEDURE example2
   DO
      PRINT "example2"
   LOOP
END PROC

SPAWN example1
SPAWN example2

DO
   RUN PARALLEL
LOOP

If you use the version 1.14.2 or better and you do not use RUN PARALLEL, the last three lines will be not needed, since they will be generated automatically at the very end of the program.

As we said earlier, procedures do not have an independent stack. This means that it is not possible to use local variables, at least not directly. More precisely, each variable is shared among all tasks (of the same type).

PARALLEL PROCEDURE example
   DO
      x = x + 1
      PRINT x;" ";
   LOOP
END PROC


In this example, the x variable is shared among all invoked tasks. So, if you invoke 5 tasks, the value of x will be increased monotonously as well as if you invoke just one task.

To overcome this problem you can use just a global array (x(...)), the size of which will be equal to the number of tasks concurrently in execution. Each element of the x array will store the variable value for that specific task. To find out what is the number of the task being executed is, you can use the keyword TASK (or THREAD).

Let's look at this example:

DIM x(3)
GLOBAL x
PARALLEL PROCEDURE example
   DO
      x(TASK) = x(TASK) + 1
      PRINT x(TASK);" ";
   LOOP
END PROC

SPAWN example
SPAWN example
SPAWN example

When running the example, you will see that the value of x will be incremented, separately, for each task.

Finally, you can use a shorter form by enclosing the variable name inside square brackets:

' [a] -> a(TASK)
PARALLEL PROCEDURE example
   DO
      [x] = [x] + 1
      PRINT [x];" ";
   LOOP
END PROC