The Purpose and Usage of Threads

What is a Thread?

How Are Threads Created?

void taskA(void) {
	while (TRUE) {
		/* Task code here... */
	}
}

void main(void)
{
	startTask(makeTask(taskA, 0));
	startTask(makeTask(taskB, 0));
	startTask(makeTask(taskC, 0));

	suspend();
}

1. Creates a separate stack for the task.
2. Sets the task start address as the first instruction of the C function specified in makeTask.
3. Adds the task control block to the ready queue according to its priority.

Eventually a task voluntarily relinquishes control or is preempted, at which point a context switch occurs and the task at the front of the ready queue becomes the new active task. (For complete details about how a context switch occurs, see our book The Art of Real-time Programming.).

Note that the task contains an infinite "while" loop, which means that it will never terminate. However, tasks do typically relinquish control either voluntarily (by using pause, yield, waitMsg, waitMail, etc.) or involuntarily (when the task is preempted by a higher priority task, or by time-slicing if time-slicing is enabled), and in this way other tasks will run in spite of the infinite loop.

Each Task has its Own Stack

1. Since local data is stored on the stack, each task instance will have its own private local data.
2. Function call nesting between context switches is preserved.
3. The task's machine context (registers, flags, etc.) are conveniently stored on and restored from the stack.

#define BEGIN 1000

void ioTask(void)
{
	int myIoAddress;
	typeMsg * msg;

	msg = waitMsg(BEGIN);
	myIoAddress = msg->iData;
	freeMsg(msg);

	while (TRUE) {
		pause(100L);
		doIo(myIoAddress);
	}
}

void main(void)
{
	int i;
	int ioAddresses[] = {0x1204, 0x1306, 0x1408};
	typeMsg * msg;
	typeTcb * tcb;
	
	for (i = 0; i < 3; i++) {
		tcb = startTask(makeTask(ioTask, i));
		msg = makeMsg(tcb, BEGIN);
		msg->iData = ioAddresses[i];
		sendMsg(msg);		
	}

	suspend();
}

It is important to understand that each task instance uses the same code, which in the example above is the function ioTask. That is, although each task gets its own stack, and therefore its own private local data, function call nesting information, and context save area, the actual task machine instructions are shared between all the task instances. This works because the code is generic, that is, it only references data on the stack, and therefore references only data for that instance. In contrast, the code below would cause a problem.

void ioTask(void)
{
	static int myIoAddress;
	typeMsg * msg;

	msg = waitMsg(BEGIN);
	myIoAddress = msg->iData;
	freeMsg(msg);

	while (TRUE) {
		pause(100L);
		doIo(myIoAddress);
	}
}

1. Task instance 0 will run and set myIoAddress to 0x1204, then enter the infinite while loop, call the function doIo with argument 0x1204, then pause for 100 milliseconds.
2. Task instance 1 will run and set myIoAddress to 0x1306, then enter the infinite while loop, call the function doIo with argument 0x1306, then pause for 100 milliseconds.
3. Task instance 2 will run and set myIoAddress to 0x1408, then enter the infinite while loop, call the function doIo with argument 0x1204, then pause for 100 milliseconds.
4. Eventually, task instance 0 will resume due to the 100 millisecond timer expiring, and it will call the function doIo with argument 0x1408 instead of 0x1204, and similarly now for all instances.

However, this does not preclude the use of static or global data by task instances. The following code fragment has the same effect as the previous example, but uses global data to accomplish it.

int IoAddresses[] = {0x1204, 0x1306, 0x1408};

void ioTask(void)
{
	int myIoAddress;

	myIoAddress = IoAddresses[ActiveTcb->taskNum];

	while (TRUE) {
		doIo(myIoAddress);
		pause(100L);
	}
}

void main(void)
{
	int i;
	
	for (i = 0; i < 3; i++) {
		startTask(makeTask(ioTask, i));
	}

	suspend();
}

Why use a Thread Instead of a Process?

Processes, however, are typically autonomous; that is, they are typically not dependent upon one another, and therefore, do not share data, nor do they need to synchronize with one another. However, since threads are part of the same application, they typically need to share data and synchronize. For example, in a data acquisition application, let us assume that taskA reads external data, while taskB displays data each time new data is available. taskB waits for a message named NEW_DATA_AVAILABLE, which means that taskB will suspend until it receives the message NEW_DATA_AVAILABLE. When taskA has data available it sends a NEW_DATA_AVAILABLE message to taskB which will wake up taskB so that it can receive the message. How taskB gets the data is a matter of design. taskB could obtain the new data in any of the following ways.

1. The data could be global data which taskA would update before sending the message to taskB. Since taskB only accesses the data after it receives a message, no synchronization problems can arise, as long as taskB processes the data before taskA writes the next new data set (we assume that taskA is the only task writing the data set, otherwise, the data set may need to be protected. See a previous article for details).
2. The NEW_DATA_AVAILABLE message could contain a pointer to the new data set. taskB would then dereference the pointer to obtain the new data to display.
3. If the new data is small, like a single integer, the NEW_DATA_AVAILABLE message could contain the new data item itself.

Finally, as a side note, processes can in fact share data if the operating system and hardware allow for it, but for small embedded applications, the operating system, or the hardware may not have the ability to accomplish this and therefore, processes cannot be created. For more information on processes and threads see a previous article.