QSemaphore - Robust integer semaphore

       #include <qthread.h>

       Inherits Qt.

   Public Members
       QSemaphore ( int )
       virtual ~QSemaphore ()
       int available () const
       int total () const
       int operator++ ( int )
       int operator-- ( int )
       int operator+= ( int )
       int operator-= ( int )


DESCRIPTION

       The QSemaphore class provides a robust integer semaphore.

       QSemaphore can be used to serialize thread execution,
       similar to a QMutex. A semaphore differs from a mutex, in
       that a semaphore can be accessed by more than one thread
       at a time.

       An example would be an application that stores data in a
       large tree structure. The application creates 10 threads
       (commonly called a thread pool) to do searches on the
       tree. When the application searches the tree for some
       piece of data, it uses one thread per base node to do the
       searching. A semaphore could be used to make sure that 2
       threads don't try to search the same branch of the tree.

       A real world example of a semaphore would be dining at a
       restuarant. A semaphore initialized to have a maximum
       count equal to the number of chairs in the restuarant. As
       people arrive, they want a seat. As seats are filled, the
       semaphore is accessed, once per person. As people leave,
       the access is released, allowing more people to enter. If
       a party of 10 people want to be seated, but there are only
       9 seats, those 10 people will wait, but a party of 4
       people would be seated (taking the available seats to 5,
       making the party of 10 people wait longer).


MEMBER FUNCTION DOCUMENTATION


QSemaphore::QSemaphore ( int maxcount )

       Creates a new semaphore. The semaphore can be concurrently
       accessed at most maxcount times.


QSemaphore::~QSemaphore () [virtual]

       Destroys the semaphore.

       This function returns the number of accesses currently
       available to the semaphore.


int QSemaphore::operator++ ( int )

       Postfix ++ operator.

       Try to get access to the semaphore. If available() is >=
       total(), this call will block until it can get access.


int QSemaphore::operator+= ( int n )

       Try to get access to the semaphore. If available() is >=
       total(), the calling thread blocks until it can get
       access. The calling will only get access from the
       semaphore if it can get all n accesses at once.


int QSemaphore::operator-- ( int )

       Postfix -- operator.

       Release access of the semaphore. This wakes all threads
       waiting for access to the semaphore.


int QSemaphore::operator-= ( int n )

       Release n accesses to the semaphore.


int QSemaphore::total () const

       This function returns the total number of accesses to the
       semaphore.


SEE ALSO

       http://doc.trolltech.com/qsemaphore.html
       http://www.trolltech.com/faq/tech.html


COPYRIGHT

       Copyright 1992-2001 Trolltech AS,
       http://www.trolltech.com.  See the license file included
       in the distribution for a complete license statement.


AUTHOR

       Generated automatically from the source code.


BUGS

       If you find a bug in Qt, please report it as described in
       http://doc.trolltech.com/bughowto.html.  Good bug reports
       make our job much simpler. Thank you.

       In case of content or formattting problems with this
       manual page, please report them to qt-bugs@trolltech.com.
       Please include the name of the manual page
       (qsemaphore.3qt) and the Qt version (2.3.1).


Man(1) output converted with man2html