arquivos-html/html/_t_p_z_semaphore_8cpp_source.html

 #include "TPZSemaphore.h"

 #include <fstream>

 #include "pzlog.h"

 #ifdef LOG4CXX
 static LoggerPtr logger(Logger::getLogger("pz.util.semaphore"));
 #endif

 TPZSemaphore::TPZSemaphore(void)
 {
                 fCounter = 0;
         PZ_PTHREAD_MUTEX_INIT(&fMutex, NULL, "TPZSemaphore::TPZSemaphore()");
         PZ_PTHREAD_COND_INIT(&fCond, NULL, "TPZSemaphore::TPZSemaphore()");
 }

 TPZSemaphore::~TPZSemaphore(void)
 {
         PZ_PTHREAD_MUTEX_DESTROY(&fMutex, "TPZSemaphore::~TPZSemaphore()");
         PZ_PTHREAD_COND_DESTROY(&fCond, "TPZSemaphore::~TPZSemaphore()");
 }

 TPZSemaphore::TPZSemaphore(int initCount)
 {
                 fCounter = initCount;
         PZ_PTHREAD_MUTEX_INIT(&fMutex, NULL, "TPZSemaphore::TPZSemaphore(int)");
         PZ_PTHREAD_COND_INIT(&fCond, NULL, "TPZSemaphore::TPZSemaphore(int)");
 }

 void TPZSemaphore::Wait()
 {
         PZ_PTHREAD_MUTEX_LOCK(&fMutex, "TPZSemaphore::Wait()");
                 if (fCounter > 0)
                 {
                                 fCounter--;
 #ifdef LOG4CXX
                                 if(logger->isDebugEnabled())
                                 {
                                                 std::stringstream sout;
 #ifdef VC
                                                 sout << "THREAD IN SEMAPHORE WAIT: " << pthread_self().x <<" " <<__LINE__ << std::endl;
 #else
                                                 sout << "THREAD IN SEMAPHORE WAIT: " << pthread_self() <<" " <<__LINE__ << std::endl;
 #endif
                                                 sout << "FCOUNTER VALUE : " << fCounter << std::endl;
                                                 LOGPZ_DEBUG(logger,sout.str())
                                 }
 #endif
                                 PZ_PTHREAD_MUTEX_UNLOCK(&fMutex, "TPZSemaphore::Wait()");
                                 return;
                 }
                 while (fCounter == 0) {
                 PZ_PTHREAD_COND_WAIT(&fCond, &fMutex, "TPZSemaphore::Wait()");
                                 if (fCounter > 0) {
                                                 fCounter--;
 #ifdef LOG4CXX
                                                 if(logger->isDebugEnabled())
                                                 {
                                                                 std::stringstream sout;
 #ifdef VC
                                                                 sout << "THREAD IN SEMAPHORE AFTER WAIT: " << pthread_self().x <<" " << __LINE__ << std::endl;
 #else
                                                                 sout << "THREAD IN SEMAPHORE AFTER WAIT: " << pthread_self() <<" " << __LINE__ << std::endl;
 #endif
                                                                 sout << "FCOUNTER VALUE : " << fCounter << std::endl;
                                                                 LOGPZ_DEBUG(logger,sout.str())
                                                 }
 #endif
                                                 PZ_PTHREAD_MUTEX_UNLOCK(&fMutex, "TPZSemaphore::Wait()");
                                                 return;
                                 }
                 }

 }

 void TPZSemaphore::Post()
 {
                 PZ_PTHREAD_MUTEX_LOCK(&fMutex, "TPZSemaphore::Post()");
                 fCounter++;
 #ifdef LOG4CXX
                 if(logger->isDebugEnabled())
                 {
                                 std::stringstream sout;
 #ifdef VC
                                 sout << "THREAD IN SEMAPHORE POST: " << pthread_self().x <<" " << __LINE__ << std::endl;
 #else
                                 sout << "THREAD IN SEMAPHORE POST: " << pthread_self() <<" " << __LINE__ << std::endl;
 #endif
                                 sout << "FCOUNTER VALUE : " << fCounter << std::endl;
                                 LOGPZ_DEBUG(logger,sout.str())
                 }
 #endif
                 PZ_PTHREAD_COND_SIGNAL(&fCond, "TPZSemaphore::Post()");
                 PZ_PTHREAD_MUTEX_UNLOCK(&fMutex, "TPZSemaphore::Post()");
                 return;
 }
PZ_PTHREAD_MUTEX_UNLOCK
#define PZ_PTHREAD_MUTEX_UNLOCK(mutex, fn)
Definition: pz_pthread.h:79

TPZSemaphore.h
Contains declaration of the TPZSemaphore class which implements semaphore to threads.

PZ_PTHREAD_COND_SIGNAL
#define PZ_PTHREAD_COND_SIGNAL(cond, fn)
Definition: pz_pthread.h:130

TPZSemaphore::fCond
pthread_cond_t fCond
Condition for the thread must to be waiting.
Definition: TPZSemaphore.h:23

pzlog.h
Contains definitions to LOGPZ_DEBUG, LOGPZ_INFO, LOGPZ_WARN, LOGPZ_ERROR and LOGPZ_FATAL, and the implementation of the inline InitializePZLOG(string) function using log4cxx library or not. It must to be called out of "#ifdef LOG4CXX" scope.

PZ_PTHREAD_COND_WAIT
#define PZ_PTHREAD_COND_WAIT(cond, mutex, fn)
Definition: pz_pthread.h:127

PZ_PTHREAD_COND_INIT
#define PZ_PTHREAD_COND_INIT(cond, attr, fn)
Definition: pz_pthread.h:121

TPZSemaphore::fCounter
int fCounter
Counter of the times the semaphore is locked.
Definition: TPZSemaphore.h:19

PZ_PTHREAD_MUTEX_LOCK
#define PZ_PTHREAD_MUTEX_LOCK(mutex, fn)
Definition: pz_pthread.h:76

LOGPZ_DEBUG
#define LOGPZ_DEBUG(A, B)
Define log for debug info.
Definition: pzlog.h:87

TPZSemaphore::Post
void Post()
Definition: TPZSemaphore.cpp:82

PZ_PTHREAD_MUTEX_DESTROY
#define PZ_PTHREAD_MUTEX_DESTROY(mutex, fn)
Definition: pz_pthread.h:73

PZ_PTHREAD_COND_DESTROY
#define PZ_PTHREAD_COND_DESTROY(cond, fn)
Definition: pz_pthread.h:124

TPZSemaphore::~TPZSemaphore
~TPZSemaphore(void)
Default destructor.
Definition: TPZSemaphore.cpp:23

TPZSemaphore::fMutex
pthread_mutex_t fMutex
Mutex for the thread.
Definition: TPZSemaphore.h:21

TPZSemaphore::TPZSemaphore
TPZSemaphore(void)
Default constructor.
Definition: TPZSemaphore.cpp:16

TPZSemaphore::Wait
void Wait()
Definition: TPZSemaphore.cpp:36

PZ_PTHREAD_MUTEX_INIT
#define PZ_PTHREAD_MUTEX_INIT(mutex, attr, fn)
Definition: pz_pthread.h:70