threadDeath3.cc

Go to the documentation of this file.

#include <iostream>
#include <stack>
#include <map>
#include <algorithm>
#include <cstring>
#include <pthread.h>

class ThreadMgr {
private:
  struct func_arguments
  {
    void *(*func)(void *);

    void (*cancel_func)(void *);

    void *arg;

    ThreadMgr *thisObject;      
  };
  
public:
  ThreadMgr() 
  { 
    //the data mutex
    static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; 
    m_mutex = &mutex; 

    //the condition variable mutex
    static pthread_mutex_t cond_mutex = PTHREAD_MUTEX_INITIALIZER;
    m_cond_mutex = &cond_mutex;

    //the condition variable
    static pthread_cond_t cond_var = PTHREAD_COND_INITIALIZER;
    m_cond_var = &cond_var;
  }

  int cancel_thread(pthread_t *tid)
  {
    //cancel a thread
    int ret = 0;
    pthread_mutex_lock(m_mutex);        //lock the data mutex 
    m_ids.erase(*tid);                  //remove from id map

    //cancel the thread
    ret = pthread_cancel(*tid);
    
    pthread_mutex_unlock(m_mutex);      // unlock data mutex

    return ret; 
  }

  int condWait(void **thread_return_val)
  {
    int ret = 0;
    
    //condition variable mutex lock
    pthread_mutex_lock(m_cond_mutex);

    //check predicate
    while(no_threads_terminated())
      {
        //wait on condition variable
        pthread_cond_wait(m_cond_var, m_cond_mutex);
      }


    //remove the thread from the terminated list (handle join)
    ret = removeTerminated(thread_return_val);

    //unlock
    pthread_mutex_unlock(m_cond_mutex);

    //return join status
    return ret;
  }

  //int createThread( void *(*thread_func)(void *), void *arg)
  pthread_t createThread( void *(*thread_func)(void *), void *arg)
  {
    pthread_t tid = 0;          // Id of thread
    int ret_val;                // return value
 
    //arguments for the function
    struct func_arguments *arguments = new func_arguments;

    arguments->func = thread_func;      // users function
    arguments->cancel_func = NULL;      // NOT IMPLIMENTED
    arguments->arg = arg;               // users argument

    //this is the this pointer (so far, every thread get's one -eek!)
    arguments->thisObject = this;

    //create a new thread
    /*
      default attributes (for now), 
      internal function, func(), calls users function,
      arguments contain other info + user's argument.
    */
    ret_val = pthread_create(&tid, (pthread_attr_t *) NULL, func, (void *)arguments);

    if(ret_val == 0)
      {
        //register the thread and arguments in the ids map
        addID(tid, arguments);
    
        //return thread id
        return tid;
      }
    else
      std::cout << "pthread_create FAIL" << std::endl;


    //return 0 on error
    return 0;
  }
  
  int threadsActive()
  { 
    pthread_mutex_lock(m_mutex);
    int ret =  m_ids.size(); 
    pthread_mutex_unlock(m_mutex);
    
    return ret;
  }
    
  bool no_threads_terminated()
  {
    pthread_mutex_lock(m_mutex);
    bool ret = m_terminated.empty();
    pthread_mutex_unlock(m_mutex);
    return ret;
  }
    


protected:
  static void *func(void *arg)
  {
    //convenience this object
    ThreadMgr *thisObject = ((struct func_arguments *)arg)->thisObject;

    //return argument from user function
    void *tmpArg = NULL;

    //basic cancel stuff -should be more robust
    struct func_arguments *cancel_arg = new func_arguments;
    cancel_arg->cancel_func = shutdown_thread;
    cancel_arg->func = NULL;
    cancel_arg->arg = NULL;
    cancel_arg->thisObject = thisObject;

    //set the cleanup function
    pthread_cleanup_push(shutdown_thread, (void *)cancel_arg);

    //call the user's function
    tmpArg = ((struct func_arguments *)arg)->func( ((struct func_arguments *)arg)->arg );
    //std::cout << "func() passing \"" << *(std::string *)tmpArg << "\" to pthread_exit()" << std::endl;

    //delete (struct func_arguments *)arg;

    //pop the cleanup handler off the cleanup stack
    //delete the arg variable list from the createThread function.
    pthread_cleanup_pop(1);
    
    //add this thread to the terminated list
    thisObject->addTerminated(thisObject);

    //exit this thread
    pthread_exit(tmpArg);

    //we will never get here
    return NULL;
  }

  static void *addTerminated(ThreadMgr *arg)
  { 
    //pthread_mutex_lock(((ThreadMgr *)arg)->m_mutex);
    pthread_mutex_lock(arg->m_mutex);

    //add self to list of stuff to be terminated (joined)
    arg->m_terminated.push(pthread_self());

    //broadcast to threads waiting on the condition variable to notify
    //them to wake up
    pthread_cond_broadcast(arg->m_cond_var);

    pthread_mutex_unlock(arg->m_mutex);

    //return NULL -blah
    return NULL;
  }

  int removeTerminated(void **return_val)
  {
    int ret = 0;
    pthread_t tempID;

    //lock critical section
    pthread_mutex_lock(m_mutex);

    //make sure we have something
    if(!m_terminated.empty())
      {
        //get id from stack
        tempID = m_terminated.top();

        //join with the terminated thread
        if( (ret = pthread_join(tempID, return_val)) == 0)
          {
            //delete the arguments (created in createThread)
            //delete m_ids.find(tempID)->second;
            
            //get rid of the ID from active list
            m_ids.erase(tempID);
            
            //remove id from stack
            m_terminated.pop();
          }
        else
          std::cout << "pthread_join() = " << ret << std::endl;
      }

    //unlock critical section
    pthread_mutex_unlock(m_mutex);

    //return value of pthread_join
    return ret;
  }

  void addID(pthread_t id, func_arguments *arg)
  {
    //lock the data mutex
    pthread_mutex_lock(m_mutex);
    
    //add the thread to the std::map
    m_ids.insert(std::make_pair(id, arg));

    //unlock the data mutex
    pthread_mutex_unlock(m_mutex);
  }
  
  static void shutdown_thread(void *arg)
  {
    delete ((struct func_arguments *)arg);
    return;
  }


private:
  pthread_mutex_t *m_mutex;

  pthread_mutex_t *m_cond_mutex;
  
  pthread_cond_t *m_cond_var;

  std::map<pthread_t, ThreadMgr::func_arguments *> m_ids;

  std::stack<pthread_t> m_terminated;
};


//################## PROTOTYPES
void waitStringThreads(ThreadMgr *mgr, void **return_value);

void *myfunc0(void *arg);

void *myfunc1(void *arg);

void *myfunc2(void *arg);

void *myStringFunc(void *arg);

template <class T>
void TwaitStringThreads(ThreadMgr *mgr, T return_value);

//################## MAIN
int main(int argc, char *argv[])
{
  void **return_val;
  void **ret;

  //string literal for later use
  const char *pc = "987654321";

  //string object of later use (example 2)
  std::string *str = new std::string("a string from main");

  //some thread IDs to track
  pthread_t pret, pret2;

  //common variable
  int i = 0;

  //the thread manager class
  ThreadMgr m;

  
  //##########################################################
  std::cout << "Example 1:" << std::endl;
  //##########################################################

  //test the functionality 
  pret = m.createThread((void *(*)(void *))myfunc0, NULL);
  pret = m.createThread((void *(*)(void *))myfunc2, (void *)pc);
  pret = m.createThread((void *(*)(void *))myfunc1, NULL);
  pret2 = m.createThread((void *(*)(void *))myfunc2, (void *)pc);
  pret = m.createThread((void *(*)(void *))myfunc1, NULL);
  pret2 = m.createThread((void *(*)(void *))myfunc2, (void *)pc);
  pret = m.createThread((void *(*)(void *))myfunc1, NULL);
  pret = m.createThread((void *(*)(void *))myfunc1, NULL);

  while(m.threadsActive())
    {
      /*do, while there are active threads or there are threads being
        terminated.
      */

      //on the third itteration...
      if(i++ == -1)
        {
          //cancel a thread (may lose data this way though!)
          std::cout << "CANCELING THREAD:" << pret2 << std::endl;
          m.cancel_thread(&pret2);
          
          //create another thread for fun and profit
          pret = m.createThread((void *(*)(void *))myfunc2, (void *)pc);
        }
      else
        {
          //wait on the thread
          m.condWait(return_val);
          if(*return_val != NULL)
            {
              std::cout << "#######################main:" << ((char *)(char *)*return_val) << std::endl;

              /* This cast is not entirely proper. See the next
                 example for proper casting when deleting this pointer.
              */
              delete (char *)*return_val;
            }
        }
    }


  //##########################################################
  std::cout << "\n" << "Example 2:" << std::endl;
  //##########################################################

  //test the functionality 
  pret = m.createThread((void *(*)(void *))myfunc0, NULL);
  pret = m.createThread((void *(*)(void *))myfunc2, (void *)pc);
  pret = m.createThread((void *(*)(void *))myfunc1, NULL);
  pret2 = m.createThread((void *(*)(void *))myfunc2, (void *)pc);
  pret = m.createThread((void *(*)(void *))myfunc1, NULL);
  pret2 = m.createThread((void *(*)(void *))myfunc2, (void *)pc);
  pret = m.createThread((void *(*)(void *))myfunc1, NULL);
  pret = m.createThread((void *(*)(void *))myfunc1, NULL);

  while(m.threadsActive())
    {
      /*do, while there are active threads or there are threads being
        terminated.
      */

      //wait on the thread
      m.condWait(return_val);

      /* check return_val: meanwhile other threads may be dieing
       */
      if(*return_val != NULL)
        {
          /* We should get here 3 times from our usage of myfunc2
             above */
          std::cout << "#######################main:" << ((char *)(char *)*return_val) << std::endl;

          //delete the pointer since it was valid (not NULL)
          delete ((char *)(char *)*return_val);
        }
    }


  //##########################################################
  std::cout << "\n" << "Example 3:" << std::endl;
  //##########################################################

  //void **ret;

  //try to pass an object and get one back
  m.createThread(myStringFunc, (void *)str);

  //while(m.threadsActive() || !m.no_threads_terminated())
  while(m.threadsActive())
    {
      //wait on the thread
      m.condWait(ret);
      if(*ret != NULL)
        {
          //cast the return_val -contents of a std::string pointer
          std::cout << *((std::string *)(std::string *)*ret) << std::endl;
          
          //delete the memory at the pointer
          delete ((std::string *)(std::string *)*ret);
        }

    }//end while()
  
  std::cout << "threads Active:" << m.threadsActive() << std::endl;
  std::cout << "no_threads_terminated:" << m.no_threads_terminated() << std::endl;

  //cleanup
  delete str;

  //##########################################################
  std::cout << "\n" << "Example 4:" << std::endl;
  //##########################################################

  //let's try another instance in tandum
  ThreadMgr m1;

  //create a couple of strings
  std::string *str1 = new std::string("string1 from main");
  std::string *str2 = new std::string("string2 from main");

  //create a thread under m1 instance of ThreadMgr
  m1.createThread(myStringFunc, (void *)str1);

  //create a thread under m instance of ThreadMgr
  m.createThread(myStringFunc, (void *)str2);


  //manage threads from m instance of ThreadMgr
  waitStringThreads(&m, ret);

  //manage threads from m1 instance of ThreadMgr
  TwaitStringThreads(&m1, (std::string **)ret);

  
  //cleanup
  delete str1;
  delete str2;
  
  //exit normally
  return(0);
}

void waitStringThreads(ThreadMgr *mgr, void **return_value)
{
  //void **return_value;                // doesn't work !!!!

  while(mgr->threadsActive())
    {
      //wait on the thread
      mgr->condWait((void **)return_value);

      if(*return_value != NULL)
        {
          //cast the return_val -contents of a std::string pointer
          std::cout << "waitStringThreads:" << *((std::string *)(std::string *)*return_value) << std::endl;
          
          //delete the memory at the pointer
          delete ((std::string *)(std::string *)*return_value);
        }
    }//end while()
}

template <class T>
void TwaitStringThreads(ThreadMgr *mgr, T return_value)
{
  while(mgr->threadsActive())
    {
      //wait on the thread
      mgr->condWait((void **)return_value);

      if(*return_value != NULL)
        {
          //cast the return_val -contents of a T pointer

          /* if we pass in a string ** then this translates to: 
          **(string **)return_value for the call to cout. remember, if
          return_value is a pointer to an object then we want the
          contents of the pointed to item of the pointer (it's a pointer
          to a pointer to a pointer to something)
          */
          std::cout << "TwaitStringThreads:" << **((T)return_value) << std::endl;
          
          //delete the memory at the pointer
          delete *return_value;
        }
    }//end while()
}

void *myStringFunc(void *arg)
{
  //copy the string using casts
  //std::string *a = ((std::string *)arg);
  //std::cout << "myStringFunc printing:" << *a << std::endl;

  //print the contents of arg as an std::string pointer
  std::cout << "myStringFunc printing:" << *(std::string *)arg << std::endl;
  
  //create a new string to be returned to the calling thread
  std::string *s = new std::string("a string from myStringFunc");
  std::cout << "myStringFunc returning:" << *s << std::endl;

  //cast the object as a void pointer and return
  return ((void *)s);

  //return ((void *)NULL);
}

void *myfunc0(void *arg)
{
  std::cout << "got here: myfunc0:BEGIN" << std::endl;

  for(int i=10000; i > 0; i--)
    for(int i=10000; i > 0; i--);

  std::cout << "got here: myfunc0:END" << std::endl;

  return NULL; 
}

void *myfunc1(void *arg)
{
  std::cout << "got here: myfunc1:BEGIN" << std::endl;

  for(int i=1000; i > 0; i--)
    for(int i=10000; i > 0; i--);

  std::cout << "got here: myfunc1:END" << std::endl;

  return NULL; 
}

void *myfunc2(void *arg)
{
  std::cout << "got here: myfunc2:BEGIN" << std::endl;

  //print the value of arg from main
  std::cout << "|arg = " << (char *)arg << std::endl;

  //create a new char and add data to the memory area
  char *tmp = new char[10];
  char x[10] = {"123456789"};

  //cheezy, but whatever...
  memcpy(tmp, x, 10);

  std::cout << "myfunc2:" << tmp << std::endl;

  for(int i=10000; i > 0; i--)
    for(int i=10000; i > 0; i--);

  std::cout << "got here: myfunc2:END" << std::endl;

  return tmp;
}