threadDeath3.cc File Reference

Thread Management Class (complex) More...

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

Include dependency graph for threadDeath3.cc:

Go to the source code of this file.

Classes
class	ThreadMgr
	A basic thread management class. More...
struct	ThreadMgr::func_arguments
	structure for static wrapper function arguments More...

Functions
void	waitStringThreads (ThreadMgr *mgr, void **return_value)
	generic wait for string-centric threads More...
void *	myfunc0 (void *arg)
	Example Thread function. More...
void *	myfunc1 (void *arg)
	Example Thread function. More...
void *	myfunc2 (void *arg)
	Example Thread function. More...
void *	myStringFunc (void *arg)
	Example Thread function returning an object. More...
template<class T >
void	TwaitStringThreads (ThreadMgr *mgr, T return_value)
	Example template -waits for thread and prints object. More...
int	main (int argc, char *argv[])
	the main function More...

Detailed Description

Thread Management Class (complex)

Purpose:

Example class that manages threads and the detection of their exits (death) through the use of condition variables. Please see the example code and ThreadMgr class documentation for more details.

For more fundamental examples see documentation for files threadDeath1.cc and threadDeath2.cc.

The class ThreadMgr uses a map and a stack from the C++ STL to track thread IDs and their runtime status. While ThreadMgr does add some overhead to basic pthread management (in the form of some memory usage and slightly slower thread creation and destruction) the class offers a relatively easy to use interface to pthreads in general and may be enhanced for better type recognition (i.e. making it a template) and the like.

Definition in file threadDeath3.cc.

Function Documentation

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

the main function

Example 1:

A slightly overcomplicated example that attempts to cancel a thread. The thread attributes have not been set to be cancelable so milage may vary from system to system. The cancelation routine is not very robust here -this is just for demonstratio purposes to show the kinds of things we might want to do with a class implimentation like that of ThreadMgr.

Example 2:

A less complicated implimentation of Example 1. Here we don't cancel any threads.

Example 3:

Demonstrates creating a thread that both passes arguments to the user defined function as well as gets something back from the call to condWait (ultimately from pthread_join)

Note

we use a different pointer in the third example to provide a cleaner example of returning an object

 \warning an attempt to declare void **ret after example 3

yielded a consistant segmentation fault using "g++ (GCC) 3.3.3 20040125" this is considered to be a compler or linker error -I didn't bother trying to figure it out (just be aware that these things happen sometimes).

Example 4:

Demonstrates the use of two instances of the ThreadMgr class. While some of the functionality of the class uses static functions, the thread management of each instance stays with the instance. In other words, each instance of ThreadMgr manages it's own private list of threads (the threads are managed seperately).

Definition at line 448 of file threadDeath3.cc.

References ThreadMgr::cancel_thread(), ThreadMgr::condWait(), ThreadMgr::createThread(), myfunc0(), myfunc1(), myfunc2(), myStringFunc(), ThreadMgr::no_threads_terminated(), ThreadMgr::threadsActive(), TwaitStringThreads(), and waitStringThreads().

{
  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);
}

Here is the call graph for this function:

void * myfunc0

(

void *

arg

)

Example Thread function.

Simply counts and returns.

Returns

NULL is returned

Definition at line 781 of file threadDeath3.cc.

Referenced by main().

{
  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

)

Example Thread function.

Simply counts and returns in less time than myfunc0

Returns

NULL is returned

Definition at line 798 of file threadDeath3.cc.

Referenced by main().

{
  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

)

Example Thread function.

Purpose:

Allocate some memory and add data to the memory area. Then wait for some amount of time (in a for loop) and return a pointer to the allocated memory.

Parameters

a

void *

Returns

a char * cast to a void *

Returns

a pointer to the new memory memory area that was populated earlier

Definition at line 819 of file threadDeath3.cc.

Referenced by main().

{
  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;
}

void * myStringFunc

(

void *

arg

)

Example Thread function returning an object.

Purpose:

Print the parameter from main, allocate memory and populate the new memory with data, and return a pointer to the new memory area (of type string pointer cast to a void *).

Parameters

arg	a void pointer

Returns

a string pointer cast to a void pointer

Definition at line 758 of file threadDeath3.cc.

Referenced by main().

{
  //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);
}

template<class T >

void TwaitStringThreads	(	ThreadMgr *	mgr,
		T	return_value
	)

Example template -waits for thread and prints object.

Purpose:

Example template that waits for a thread and prints out the string that is the return value from the condWait. This is here for example only and EXPECTS that the Type is something printable.

Parameters

mgr	A ThreadMgr pointer
return_value	of type cast by calling function (see main for more details)

Returns

nothing

Note

a call to this function:
TwaitStringThreads(p_mgr, (string **)ret);
Yields ret to be a (string **). When we want to send it to cout then we must cast it bacwards to get the contents of the pointer of the pointer (which is a string pointer in this case). Get it?

Definition at line 723 of file threadDeath3.cc.

References ThreadMgr::condWait(), and ThreadMgr::threadsActive().

Referenced by main().

{
  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()
}

Here is the call graph for this function:

void waitStringThreads	(	ThreadMgr *	mgr,
		void **	return_value
	)

generic wait for string-centric threads

wait for a managed thread to return

Purpose:

Wait for a thread managed by the ThreadMgr pointer to return.

Parameters

mgr	A ThreadMgr class pointer
return_value	(must be from the function that calls createThread) This is a detail of how the staticness of the return value from the pthread_join is implimented -I think.

Note

This function could easily be made into a template. We're just doing this for now for demonstration purposes. Something along the lines of the following might do the trick:

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

(Of coarse, then you would have to cast your pointer from the calling function or something like that, but that's probably not that big of a deal.)

Warning

: Due to stack undwinding, declaring the void** for the return value in this scope will simply not work. The return value pointer MUST be passed in or you will get a segmentation fault.

Definition at line 656 of file threadDeath3.cc.

References ThreadMgr::condWait(), and ThreadMgr::threadsActive().

Referenced by main().

{
  //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()
}

Here is the call graph for this function: