This class handles a collection of threads. More...

#include <ONCRPCThreadCollection.h>

Inheritance diagram for JiveXML::ThreadCollection:

Collaboration diagram for JiveXML::ThreadCollection:

Public Member Functions
	ThreadCollection ()

	~ThreadCollection ()

Private Attributes
T	elements
	STL member. More...

Public interface functions
pthread_mutex_t	m_mutex

sem_t	m_semaphore

void	AddThread (const pthread_t &thread)

void	WaitAdd ()

void	RemoveThread (const pthread_t &thread)

void	JoinAll ()

int	NumberOfThreads ()

Detailed Description

This class handles a collection of threads.

Definition at line 17 of file ONCRPCThreadCollection.h.

Constructor & Destructor Documentation

◆ ThreadCollection()

JiveXML::ThreadCollection::ThreadCollection ( )

Definition at line 11 of file ONCRPCThreadCollection.cxx.

                                     {
  
     //intialize the mutex with default attributes
     pthread_mutex_init(&m_mutex, NULL);
  
     //initialize the semaphore
     sem_init(&m_semaphore,0,0);
  
   }

◆ ~ThreadCollection()

JiveXML::ThreadCollection::~ThreadCollection ( )

Definition at line 22 of file ONCRPCThreadCollection.cxx.

                                      {
  
     //destroy the mutex
     pthread_mutex_destroy(&m_mutex);
  
     //and the semaphore
     sem_destroy(&m_semaphore);
  
   }

Member Function Documentation

◆ AddThread()

void JiveXML::ThreadCollection::AddThread ( const pthread_t & thread )

Definition at line 34 of file ONCRPCThreadCollection.cxx.

                                                            {
     
     //First get a mutex //RETVAL for all of them!
     pthread_mutex_lock(&m_mutex);
  
     //Now add the thread to the list of vectors
     push_back(thread);
  
     //Then remove mutex again
     pthread_mutex_unlock(&m_mutex);
  
     //And signal any potentially waiting threads
     sem_post(&m_semaphore);
     
   }

◆ JoinAll()

void JiveXML::ThreadCollection::JoinAll ( )

Definition at line 88 of file ONCRPCThreadCollection.cxx.

                                 {
     
     //The threads are removing themselves from the list,
     //so iterators are getting invalid while we are looping.
     //However, some threads may have crashed w/o being able to remove themselves
     //So wait for all of them to finish w/o keeping the mutex locked while
     //waiting
     
     //Loop till all threads are gone
     while ( size() > 0 ){
       
       //First get a mutex //RETVAL for all of them!
       pthread_mutex_lock(&m_mutex);
  
       //Order is not important - take the first element
       pthread_t thread = *begin();
  
       //Then remove mutex again
       pthread_mutex_unlock(&m_mutex);
  
       //Wait for that thread to finish
       pthread_join(thread,NULL);
  
       //Now remove it - if it has already removed itself, nothing will happen
       //If it hadn't removed itself, we will remove it
       RemoveThread(thread);
     }
   }

◆ NumberOfThreads()

int JiveXML::ThreadCollection::NumberOfThreads ( )

Definition at line 119 of file ONCRPCThreadCollection.cxx.

                                         {
  
     //First get a mutex
     pthread_mutex_lock(&m_mutex);
  
     //Get number of elements
     int NThreads = size();
  
     //Then remove mutex again
     pthread_mutex_unlock(&m_mutex);
     
     //finally return size
     return NThreads;
   }

◆ RemoveThread()

void JiveXML::ThreadCollection::RemoveThread ( const pthread_t & thread )

Definition at line 58 of file ONCRPCThreadCollection.cxx.

                                                               {
     
     //First get a mutex
     pthread_mutex_lock(&m_mutex);
  
     //Loop over list and find that entry
     ThreadCollection::iterator threadItr = begin();
     while ( threadItr != end() ){
       //See if this is the thread we are looking for
       if ( *threadItr == thread ){
         //remove it from the collection
         erase(threadItr);
         //iterator is invalid, we removed thread, so stop looping
         break ;
       }
       //Go to next thread
       ++threadItr;
     }
  
     //Then remove mutex again
     pthread_mutex_unlock(&m_mutex);
  
     //Set this threads state to detached, so its
     //resources are reclaimed once it
     //finishes.
     pthread_detach(thread);
     
   }

◆ WaitAdd()

void JiveXML::ThreadCollection::WaitAdd ( )

Definition at line 51 of file ONCRPCThreadCollection.cxx.

                                 {
  
     //simply wait for the access semaphore to be set
     sem_wait(&m_semaphore);
   }

Member Data Documentation

◆ elements

T std::vector< T >::elements

inherited

STL member.

◆ m_mutex

pthread_mutex_t JiveXML::ThreadCollection::m_mutex

private

Definition at line 48 of file ONCRPCThreadCollection.h.

◆ m_semaphore

sem_t JiveXML::ThreadCollection::m_semaphore