Getting Started with QNX Neutrino - QNX Software Systems

Threads and processes
© 2009, QNX Software Systems GmbH & Co. KG.
pthread_attr_t attr;
// initialize the attribute structure
pthread_attr_init (&attr);
// set the detach state to "detached"
pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
// override the default of INHERIT_SCHED
pthread_attr_setinheritsched (&attr, PTHREAD_EXPLICIT_SCHED);
pthread_attr_setschedpolicy (&attr, SCHED_RR);
attr.param.sched_priority = 15;
// finally, create the thread
pthread_create (NULL, &attr, new_thread, NULL);
To see what a multithreaded program “looks like,” you could run the pidin command
from the shell. Say our program was called spud. Ifwerunpidin once before spud
created a thread and once after spud created two more threads (for three total), here’s
what the output would look like (I’ve shortened the pidin output to show only spud):
Where a thread is a good idea
# pidin
pid tid name prio STATE Blocked
12301 1 spud 10r READY
# pidin
pid tid name prio STATE Blocked
12301 1 spud 10r READY
12301 2 spud 10r READY
12301 3 spud 10r READY
As you can see, the process spud (process ID 12301) has three threads (under the “tid”
column). The three threads are running at priority 10 with a scheduling algorithm of
round robin (indicated by the “r” after the 10). All three threads are READY, meaning
that they’re able to use CPU but aren’t currently running on the CPU (another,
higher-priority thread, is currently running).
Now that we know all about creating threads, let’s take a look at how and where we’d
use them.
There are two classes of problems where the application of threads is a good idea.
Threads are like overloading operators in C++ — it may seem like a good idea (at the
time) to overload every single operator with some interesting use, but it makes the
code hard to understand. Similarly with threads, you could create piles of threads, but
the additional complexity will make your code hard to understand, and therefore hard
to maintain. Judicious use of threads, on the other hand, will result in code that is
functionally very clean.
Threads are great where you can parallelize operations — a number of mathematical
problems spring to mind (graphics, digital signal processing, etc.). Threads are also
great where you want a program to perform several independent functions while
42 Chapter 1 • Processes and Threads April 30, 2009