Basic threads management example

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <thread.h>
#define	RANGE	10
/* ARGSUSED */
void *sometask(void *dummy)
{
	thread_t thrID	= thr_self();
	unsigned seed	= getpid() * time(NULL) * (thrID + 1);
	unsigned naptime=
		(unsigned)(1 + RANGE*((double)rand_r(&seed)/(double)RAND_MAX));
	setbuf(stdout,NULL);
	(void)printf("thread %ld entering sometask\n",	thrID);
	(void)printf("thread %ld naptime %d\n",		thrID, naptime);
	(void)sleep(naptime);
	(void)printf("thread %ld leaving  sometask\n",	thrID);
	return NULL;
}

sometask

The following examples on threads management will use (either explicitly or implicitly) the function sometask that appears in ``sometask''. This function will call sleep(3C) to represent some arbitrary activity by the thread. Features to note in this example are:

• The simulated action for each thread will be different since each sleeps for a different, random period of time. The seed for the random number generator depends on current process ID, current time, and thread ID.

• The activity period is at least one second plus a random component between zero and nine seconds.

• The random number is generated with rand_r, the thread-safe version of rand(3C).

• Calls to sleep(3C) by each thread will put only the calling thread to sleep, as arranged by the wrapper version of sleep provided by the Threads Library.

#include	<stdio.h>
#include	<stdlib.h>
#include	<thread.h>
extern void	*sometask(void *);
main(int argc, char **argv)
{
     int Nthreads, i; thread_t threadID;
     if(argc != 2){
	(void)fprintf( stderr,"%s: usage: %s Nthreads\nwhere Nthreads > 0\n",
			argv[0], argv[0]);
	return 1;
     }
     if( (Nthreads = atoi(argv[1])) <= 0 ){
	(void)fprintf( stderr,"%s: usage: %s Nthreads\nwhere Nthreads > 0\n",
			argv[0], argv[0]);
	return 1;
     }
     for(i = 0; i < Nthreads; i++)
	(void)thr_create(NULL, 0, sometask, NULL, 0, NULL);
     for(i = 0; i < Nthreads; i++){
	(void)thr_join(0, &threadID, NULL);
	(void)printf("thread %ld is gone\n", threadID);
     }
     return 0;
}

Multiple threads

The program in ``Multiple threads'' creates one or more threads as follows:

• The number of threads to be created is determined by a (validated) command line parameter.

• Each new thread runs sometask.

• The initial thread waits for the termination of each thread that it creates.

#include	<stdio.h>
#include	<stdlib.h>
#include	<thread.h>
#include	<synch.h>
extern void	*sometask (void *);
static void	*repeatask(void *);
static barrier_t	common_wall;
main(int argc, char **argv)
{
     int		Nthreads, i;
     if(argc != 2){
	(void)fprintf(	stderr,"%s: usage: %s Nthreads\nwhere Nthreads > 0\n",
			argv[0], argv[0]);
	return 1;
     }
     if((Nthreads = atoi(argv[1]))>0){
	(void)barrier_init(&common_wall, Nthreads, USYNC_THREAD, NULL);
     } else {
	(void)fprintf(	stderr,"%s: usage: %s Nthreads\nwhere Nthreads > 0\n",
			argv[0], argv[0]);
	return 1;
     }
     for(i = 0; i < Nthreads; i++)
	(void)thr_create(NULL, 0, repeatask, NULL, 0, NULL);
     thr_exit(NULL);
     /*NOTREACHED*/
}
/* ARGSUSED */
static void *repeatask(void *dummy)
{
	for(;;){
		(void)printf("thread %ld at wall\n", thr_self());
		(void)barrier_wait(&common_wall);
		(void)sometask(NULL);
	}
}

barrier_wait

The example in ``barrier_wait'' is a variation of that in ``Multiple threads''. In this case:

• Each thread that is created (running repeatask) calls sometask repeatedly.

• The created threads coordinate their activity into cycles by the barrier facility of the Threads Library.

• Output of this program shows a flurry of activity as the barrier count is reached and the set of threads is unleashed for the next cycle.

• There is no need for the initial thread to persist; consequently, the initial thread terminates itself with thr_exit(3thread). The process continues until the user terminates it manually.