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.

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