How to pass a signal to unblock the pause() in Linux?

Question

This is fixed now. I have added one more program to show how it has been fixed. This program is to demonstrate how the signals are lost in multi-threading environment. This signal loss causes the race condition. The Blocking thread never gets a signal to unblock, because it misses the signal. This has the condition, and the mutex. The solution to this type of problem is to use cond_var. The cond_var protects the condition as well as the data. Thus, it will automatically locks the condition, and it unblocks the condition once the other thread signals it. The locking of condition protects it from the signal miss. The faulty program - race condition program is added here.

I have the following program. I am trying to unblock it by the call - kill. But, my program hangs because it never sends a signal to the blocked function(). I don't want to use pthread_cond since I want to demonstrate the problem here. But the signal is not lost but it never passes the signal to unblock it.

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <iostream>
/** get pid **/
#include <sys/types.h>
#include <unistd.h>
/** kill signal **/
#include <signal.h>

using namespace std;

int shared_variable = 7;

pid_t pid_A;
pid_t pid_B;



class helium_thread
{
  private:
  pthread_t *thread_id;
  pid_t process_pid;

  public:
  static pthread_mutex_t mutex_thread;
  void set_thread_id(pthread_t tid);
  pthread_t *get_thread_id();
  int create_thread(pthread_t *thread_ptr, const pthread_attr_t *attr, void * (*start_routine)(void *), void *arg );
  helium_thread();  
  ~helium_thread();

};

helium_thread thread_1, thread_2;

void helium_thread::set_thread_id( pthread_t tid)
{
   *(this->thread_id) = tid;    
}

pthread_t * helium_thread::get_thread_id( )
{
   return (this->thread_id);
}

int helium_thread::create_thread(pthread_t *thread_ptr, const pthread_attr_t *attr, void * (*start_routine)(void *), void *arg )
{
   int ret;
   ret = pthread_create(thread_ptr,attr,start_routine,(void *)arg)  ;
   cout<<"Thread created "<<std::hex<<thread_ptr<<endl;
   return ret;

}

helium_thread::helium_thread()
{

    thread_id = new pthread_t;
    cout<<"Constructor called "<<std::hex<<thread_id<<endl;
}

helium_thread::~helium_thread()
{
    cout<<"Destructor called"<<std::hex<<thread_id<<endl;
    delete thread_id;
}

/** While defining the methods of the class, Keywords static and virtual should not be repeated in the definition. **/
/** They should only be used in the class declaration. **/

void *Thread_Function_A(void *thread_arg)
{
  int rc = 0;
  pthread_mutex_lock(&(helium_thread::mutex_thread));

  pid_A = getpid();

  cout<<"The pid value of Thread A is"<< pid_A << endl;

  if ( shared_variable  == 5) 
  {
       shared_variable = 100;
       cout<<"The thread A proceeds"<<endl;
       pthread_mutex_unlock(&(helium_thread::mutex_thread));   

  }  
  else
  {   pthread_mutex_unlock(&(helium_thread::mutex_thread));
      cout<<"Going to block now"<<endl;
      rc = pause();
      cout<<"Unblocked now, the rc value is "<<rc<<endl;

  }



}

void *Thread_Function_B(void *thread_arg)
{
  pthread_mutex_lock(&(helium_thread::mutex_thread));   

  pid_B = getpid();

  cout<<"The pid value of Thread B is"<< pid_B << endl;

  shared_variable = 5;

  cout<<"Unblock the thread A now"<<endl;
  pthread_kill(*(thread_1.get_thread_id()), SIGCONT); 


  pthread_mutex_unlock(&(helium_thread::mutex_thread)); 

}

/** The definition of the static member can't be inside a function, You need to put it outside **/
/** When I tried using inside a function, I got the error - error: invalid use of qualified-name ‘helium_thread::mutex_thread **/

pthread_mutex_t helium_thread::mutex_thread = PTHREAD_MUTEX_INITIALIZER;

int main(int argc, char *argv[])
{

   pid_t thread_pid_val = getpid();

   thread_1.create_thread((thread_1.get_thread_id()),NULL,Thread_Function_A,&thread_pid_val);
   thread_2.create_thread((thread_2.get_thread_id()),NULL,Thread_Function_B,&thread_pid_val);
   pthread_join( *(thread_1.get_thread_id()), NULL);
   pthread_join( *(thread_2.get_thread_id()), NULL);

   return  0;   
}

The output is -

   $ ./thread_basic.out 
Constructor called 0x195c010
Constructor called 0x195c030
Thread created 0x195c010
The pid value of Thread A is404c
Thread created Going to block now
The pid value of Thread B is0x404c
Unblock the thread A now
0x195c030

------------------Working Race - Condition program-

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <iostream>
/** get pid **/
#include <sys/types.h>
#include <unistd.h>
/** kill signal **/
#include <signal.h>

using namespace std;

int shared_variable = 7;

pid_t pid_A;
pid_t pid_B;



class helium_thread
{
  private:
  pthread_t *thread_id;
  pid_t process_pid;

  public:
  static pthread_mutex_t mutex_thread;
  void set_thread_id(pthread_t tid);
  pthread_t *get_thread_id();
  int create_thread(pthread_t *thread_ptr, const pthread_attr_t *attr, void * (*start_routine)(void *), void *arg );
  helium_thread();  
  ~helium_thread();

};

helium_thread thread_1, thread_2;

void helium_thread::set_thread_id( pthread_t tid)
{
   *(this->thread_id) = tid;    
}

pthread_t * helium_thread::get_thread_id( )
{
   return (this->thread_id);
}

int helium_thread::create_thread(pthread_t *thread_ptr, const pthread_attr_t *attr, void * (*start_routine)(void *), void *arg )
{
   int ret;
   ret = pthread_create(thread_ptr,attr,start_routine,(void *)arg)  ;
   cout<<"Thread created "<<std::hex<<thread_ptr<<endl;
   return ret;

}

helium_thread::helium_thread()
{

    thread_id = new pthread_t;
    cout<<"Constructor called "<<std::hex<<thread_id<<endl;
}

helium_thread::~helium_thread()
{
    cout<<"Destructor called"<<std::hex<<thread_id<<endl;
    delete thread_id;
}

/** While defining the methods of the class, Keywords static and virtual should not be repeated in the definition. **/
/** They should only be used in the class declaration. **/

void handler(int sig)
{
    //do nothing
    cout<<"Handler called"<<endl;
}


void *Thread_Function_A(void *thread_arg)
{
  int rc = 0;
  pthread_mutex_lock(&(helium_thread::mutex_thread));

  pid_A = getpid();

  cout<<"The pid value of Thread A is"<< pid_A << endl;

  while(1)
  {

   if ( shared_variable  == 5) 
   {
       shared_variable = 100;
       cout<<"The thread A proceeds"<<endl;
       cout<<"The shared_variable value = "<< std::dec<< shared_variable << endl;
       pthread_mutex_unlock(&(helium_thread::mutex_thread));
       cout<<"The thread exits"<<endl;
       pthread_exit(NULL);   

   }  
   else
   {   pthread_mutex_unlock(&(helium_thread::mutex_thread));
      cout<<"Going to block now"<<endl;
      /** This sleep will give a sufficient time to schedule thread B **/
      /** Once thread B is scheduled, the thread B will sent a signal to unblock the thread A **/
      /** The signal has been sent, but this thread was not in the pause instruction **/
      sleep(5);
      cout<<"Sleep completed now"<<endl;
      /** Thread B has sent the signal; and it may be lost **/
      /** The pause will be blocked now, waiting for the signal to occur again **/
      rc = pause();
      cout<<"Unblocked now, the rc value is "<<rc<<endl;

   }

 }
}


void *Thread_Function_B(void *thread_arg)
{
  pthread_mutex_lock(&(helium_thread::mutex_thread));   

  pid_B = getpid();

  cout<<"The pid value of Thread B is"<< pid_B << endl;

  shared_variable = 5;

  cout<<"Unblock the thread A now"<<endl;

  pthread_kill(*(thread_1.get_thread_id()), SIGUSR1);

  pthread_mutex_unlock(&(helium_thread::mutex_thread));
  cout<<"Return thread function b now"<<endl; 

}

/** The definition of the static member can't be inside a function, You need to put it outside **/
/** When I tried using inside a function, I got the error - error: invalid use of qualified-name ‘helium_thread::mutex_thread **/

pthread_mutex_t helium_thread::mutex_thread = PTHREAD_MUTEX_INITIALIZER;

int main(int argc, char *argv[])
{

   pid_t thread_pid_val = getpid();
   /** Install signal handler **/
   signal(SIGUSR1, handler);      
   thread_1.create_thread((thread_1.get_thread_id()),NULL,Thread_Function_A,&thread_pid_val);
   thread_2.create_thread((thread_2.get_thread_id()),NULL,Thread_Function_B,&thread_pid_val);
   pthread_join( *(thread_1.get_thread_id()), NULL);
   pthread_join( *(thread_2.get_thread_id()), NULL);

   return  0;   
}

The output is the following .

$ ./thread_basic.out 
Constructor called 0x1e01010
Constructor called 0x1e01030
Thread created 0x1e01010
The pid value of Thread A is45a6
Going to block now
Thread created 0x1e01030
The pid value of Thread B is45a6
Unblock the thread A now
Return thread function b now
Handler called
Sleep completed now

Answer 1

Add a signal handler.

void handler(int sig)
{
    //do nothing
}

Set it up from main (or somewhere) to catch SIGUSR1 (or similar)

signal(SIGUSR1, handler);

ThreadB calls

pthread_kill(pthread_self(), SIGUSR1);

The signal handler will be run, pause will wake up and return -1 and continue on.

This will work but is still exceedingly awkward.

Answer 2

You should use pthread_t t_a = pthread_self() instead of getpid()

And pthread_kill(t_a , SIGCONT) instead of kill

SIGCONT only continues a process previously stopped by SIGSTOP or SIGTSTP

So, you might want to try:

pthread_kill(pthread_self(), SIGSTOP);

Instead of pause()

POSIX threads have condition variables for a reason; use them...

Answer 3

kill sends signals to processes and as your output shows, both your threads belong to the same process. You would need to use either pthread_kill or the linux specific tkill or mess around with pthread_sigmask to ensure that only the paused thread receives the SIGCONT signal.