Hi team!
I am a new member.I was exited to find such good interaction and just couldn't resist joining you guys out here.
Coming to the point...
I am writing small programs on Pthreads.
While the file is compiled successfully there is a runtime message"Segmentation fault"..I couldn.t understand what it is.
The program is on use of condition variables from a tutorial. While the code as it is works fine..I was just experimenting on it as follows.
I am canceling on thread from another using pthread_cancel().
Just to prevent cancelling the calling thread itself, I have used pthread_equal() to verify the threadID.
the code is below:
#include <pthread.h>
#include <stdio.h>
pthread_t threads[3];
int count = 0;
int thread_ids[3] = {0,1,2};
pthread_mutex_t count_mutex;
pthread_cond_t count_threshold_cv;
void *inc_count(void *idp)
{
int j,i;
double result=0.0;
int *my_id = idp;
for (i=0; i < TCOUNT; i++)
{
pthread_mutex_lock(&count_mutex);
count++;
if (count == COUNT_LIMIT)
{
pthread_cond_signal(&count_threshold_cv);
}
pthread_mutex_unlock(&count_mutex);
/* I have added this part*/
if(pthread_equal(pthread_self(),threads[0])==0)
{
printf("\ncancelling.......\n");
pthread_cancel(threads[0]);
}
else pthread_cancel(threads[1]);*/
printf("\nthread ID.......%d...%d\nn",pthread_self(),threads[0]);
/* Do some work so threads can alternate on mutex lock */
for (j=0; j < 1000000; j++)
result = result + (double)random();
}
pthread_exit(NULL);
}
void *watch_count(void *idp)
{
int *my_id = idp;
printf("Starting watch_count(): thread %d\n", *my_id);
/*
Lock mutex and wait for signal. Note that the pthread_cond_wait
routine will automatically and atomically unlock mutex while it waits.
Also, note that if COUNT_LIMIT is reached before this routine is run by
the waiting thread, the loop will be skipped to prevent pthread_cond_wait
from never returning.
*/
pthread_mutex_lock(&count_mutex);
while (count < COUNT_LIMIT)
{
pthread_cond_wait(&count_threshold_cv, &count_mutex);
printf("watch_count(): thread %d Condition signal received.\n", *my_id);
}
pthread_mutex_unlock(&count_mutex);
pthread_exit(NULL);
}
int main (int argc, char *argv[])
{
int i, rc;
/*pthread_t threads[3];*/
pthread_attr_t attr;
/* Initialize mutex and condition variable objects */
pthread_mutex_init(&count_mutex, NULL);
pthread_cond_init (&count_threshold_cv, NULL);
/*
For portability, explicitly create threads in a joinable state
so that they can be joined later.
*/
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
pthread_create(&threads[0], &attr, inc_count, (void *)&thread_ids[0]);
pthread_create(&threads[1], &attr, inc_count, (void *)&thread_ids[1]);
pthread_create(&threads[2], &attr, watch_count, (void *)&thread_ids[2]);
/* Wait for all threads to complete */
for (i = 0; i < NUM_THREADS; i++)
{
pthread_join(threads[i], NULL);
}
printf ("Main(): Waited on %d threads. Done.\n", NUM_THREADS);
/* Clean up and exit */
pthread_attr_destroy(&attr);
pthread_mutex_destroy(&count_mutex);
pthread_cond_destroy(&count_threshold_cv);
pthread_exit(NULL);
}
