Hi,
I have written a program which is as follows -

Thread_send()
{
send_data();
wait_for_signal(); /*wait for signal SIGUSR1 using sigwait()*/
read_data_from_buffer();
return;
}

Thread_receive()
{
while(1)
{
wait_for_data_on_socket();
read_data();
copy_data_to_buffer();
send_signal_to_thread(thread_id,SIGUSR1); /*send SIGUSR1*/
}
}


main()
{
start_thread(thread_send);
start_thread(thread_receive);
}

Now the problem is - when the program starts executing, it creates the first thread i.e thread_send and starts executing it. But sometimes, thread_read is pre-empted and main thread starts executing which in turn starts thread_receive. Now, if thread_read was pre-empted after wait_for_signal()call, there is no problem. But if it is pre-empted before wait_for_signal()call, their is no signal handler for the same and if thread_receive send a signal to thread_send, the program terminates with "User defined signal 1". Is their any way I can prevent this situation and make sure that the signal is send only after wait_for_signal() has excuted. Is it possible to make the operations
[send_data(); and wait_for_signal();] atomic so that both these operations execute together.?

Preload a signal handler from your main thread before you start any of your sub-threads. Initialize a semaphore also from your main thread before you start any of your sub-threads, make sure that the semaphore is initialized such that the next call to take it will block.

In your global signal handler, re-arm the handler and if the signal is USR1, then give the semaphore.

In your sender thread, send data and take semaphore.

In your reader read data and send signal.

<<<< OR >>>>

Just simply use a semaphore instead of a signal.

Main code creates semaphore, initializes semaphore to cause next take to block
Creates reader and sender threads

Sender thread sends data (unblocks reader thread), takes semaphore (blocks)

Reader thread blocks on read, reads data, gives semaphore (unblocks sender thread)

Anyway, you get the idea...

rstewart is absolutely correct - you need "locking", some kind of "mutual exclusion".

Depending on your specific application, you have many choices. Here's a brief tutorial that discusses pthreads mutexes:

http://students.cs.byu.edu/~cs460ta/.../pthreads.html

'Hope that helps .. PSM

PS:
My guess is that you'll probably be able to lose both "wait_for_signal()" and " send_signal_to_thread()".