/******************************************************** * An example source module to accompany... * * "Using POSIX Threads: Programming with Pthreads" *     by Brad nichols, Dick Buttlar, Jackie Farrell *     O'Reilly & Associates, Inc. * ******************************************************** * stat_sigwait.c * * Simple example of pthreads and signals. */#include <stdlib.h>#include <stdio.h>#include <unistd.h>#include <signal.h>#include <time.h>#include <sys/types.h>#include <pthread.h>#define MAX_NUM_THREADS  10pthread_mutex_t stats_lock = PTHREAD_MUTEX_INITIALIZER;int mean, samples, total;void *report_stats(void *p){  int caught;  sigset_t  sigs_to_catch;  /* Identify our thread */  printf("\nreport_stats() started.\n");   /*   * We inherited a thread sigmask with all the signals    * blocked.  So, we can wait on whatever signals we're   * interested in and (as long as no other thread waits   * for them) we'll be sure return from sigwait() to   * handle it.   */   /* set this thread's signal mask to block out SIGUSR1 */  sigemptyset(&sigs_to_catch);  sigaddset(&sigs_to_catch, SIGUSR1);  for (;;) {     sigwait(&sigs_to_catch, &caught);     pthread_mutex_lock(&stats_lock);     mean = total/samples;     printf("\nreport_stats(): mean = %d, samples = %d\n", mean, samples);     pthread_mutex_unlock(&stats_lock);  }  return NULL;}/* * worker_thread -- *  * Don't read too much into what this thread does.  It's * a very simpleminded example.  The only interesting thing * it does is write to the global statistics data-- which * means the thread processing the signal has to protect  * against simultaneous access. */void *worker_thread(void *p) {int item;time_t now;int *amtp=(int *)p;  for (;;) {    sleep((*amtp)*9);      now = time(NULL);     pthread_mutex_lock(&stats_lock);    total+=((int)now)%60; /* probably not the safest thing to do but		        it's just an example */    samples++;    pthread_mutex_unlock(&stats_lock);  }  /* Won't get here.  */  return NULL;}extern intmain(void){  int       i;  pthread_t threads[MAX_NUM_THREADS];  int       num_threads = 0;  sigset_t  sigs_to_block;  struct    sigaction action;  /* Identify our thread */  printf("main() running in thread 0x%x\n", pthread_self());   /*    * Set this thread's signal mask to block SIGUSR1   * Other thread's will inherit the mask   */  sigemptyset(&sigs_to_block);  sigaddset(&sigs_to_block, SIGUSR1);  pthread_sigmask(SIG_BLOCK, &sigs_to_block, NULL);  /* spawn statistics reporting thread */  pthread_create(&threads[num_threads++],	         NULL,		 report_stats,		 NULL);  /* spawn the threads */  for (i=num_threads; i<MAX_NUM_THREADS; i++) {    pthread_create(&threads[num_threads++],		   NULL,                   worker_thread,		   &i);  }   printf("main()\t\t\t\t%d threads created\n",num_threads);    /* wait until all threads have finished */  for (i = 0; i < num_threads; i++) {    pthread_join(threads[i], NULL);    printf("main()\t\tjoined to thread %d \n", i);  }    printf("main()\t\tall %d threads have finished. \n", num_threads);  return 0;}