Creating Threads

Syntax

To create a thread under Solaris, use function thr_create(). Note that all thread related functions start with thr_. The syntax of thr_create() is:

int  thr_create(
          NULL,       /* use this default           */
          0,          /* use this default           */
          void *(*funct)(void *),  /* thread funct  */
          void *arg,  /* argument passed to funct() */
          0,          /* use default                */
          thread_t *ID);   /* use NULL works fine   */

Calling thr_thread() will create a child thread which will execute concurrently with the parent thread (i.e., the caller). The following is the meaning of each argument:

Function funct() is called and run as a thread. Function funct() has only one argument, a pointer to void and returns a pointer to void.
arg is a pointer to void and is supplied to function funct() as its argument. Thus, if you want to send a pointer to a object whose type is not void, you need to cast that pointer to a pointer to void. Then, in function funct(), you should cast the pointer of the argument back to a pointer to the original type.
ID is a pointer to a variable of type thread_t. *ID is where the new thread's system ID is stored.
thr_create() returns an integer. Any non-zero value indicates that an error has occurred and in this case no thread is created.

Example

Click here to download a copy of the following program.

#include  <stdio.h>
#include  <thread.h>

void *count(void *JunkPTR)
{
     int  *valuePTR = (int *) JunkPTR;  /* convert to integer ptr.  */
     int  value     = *valuePTR;        /* then take the value      */

     printf("Child: value = %d\n", value);
}

void  main(void)
{
     thread_t  ID1, ID2;                /* for thread IDs                  */
     int       v1 = 1;                  /* argument for the 1st thr */
     int       v2 = 2;                  /* argument for the 2nd thr */

     thr_create(NULL, 0, count, (void *) (&v1), 0, &ID1);
     thr_create(NULL, 0, count, (void *) (&v2), 0, &ID2);
     printf("Parent\n");
     sleep(2);                          /* why is sleep() here?     */
}

The above program creates two threads, each of which is a copy of function count().
The first call to thr_create() creates the first copy of count(). The argument sent to count() is given as (void *) (&v1), which means taking the pointer to int variable v1 (i.e., &v1), converting it to a pointer to void (i.e., (void *) (&v1)), and finally putting the converted result as the fourth argument. This pointer will be received by count() as its only argument.
The sixth argument can be a NULL if we do not care about the ID of the created thread. If we do want the ID, the sixth argument must be a pointer to a variable of type thread_t. In the above example, ID1 stores the thread ID of the first thread.
Now take a look at function count(). It receives a pointer to void. To retrieve the value passed by this pointer, the argument, JunkPTR must be first converted back to the right type. In this case, it is a pointer to int. From this pointer, the value stored in v1 in the main program can be retrieved and saved to variable value. Therefore, value receives 1. Consequently, printf will display 1.
Once the first copy of count() is created and running, the main program reaches the second thr_create(), which creates a second copy of count() and sends the value of v2. If this creation is successful, we have three threads running: (1) the main program, (2) the first copy of count() and the second copy of count().
In the second copy of count(), variable value receives 2. Although both copies have value, they are different because they belong to different copies of count().
After creating two copies of count(), the main program displays a message and sleeps for two seconds. Note that sleep() is a Unix system call. But, why is a call to sleep() required here? Can we remove it?
Well, we cannot remove this sleep(). Since the two copies of count() are child threads of the main program which is the parent. If parent exits, all of its child threads exit as well. Thus, if sleep() is not there and if the main runs faster than any one copy of count(), it is possible that before count() can display anything, the main program exits. As a result, you won't see anything displayed from count(). Therefore, the call to sleep() here is to delay the main program a little until the messages from copies of count() can be displayed.
Using sleep() is definitely not a good practice. You will learn a better way to do this with thr_join().

The following diagram shows the three concurrently executing threads, one parent (i.e., the main program) and two children (i.e., the two copies of count()).