QThread - Platform-independent threads

       #include <qthread.h>

       Inherits Qt.

   Public Members
       QThread ()
       virtual ~QThread ()
       bool wait ( unsigned long time = ULONG_MAX )
       void start ()
       bool finished () const
       bool running () const

   Static Public Members
       HANDLE currentThread ()
       void postEvent ( QObject *, QEvent * )
       void exit ()

   Protected Members
       virtual void run ()

   Static Protected Members
       void sleep ( unsigned long )
       void msleep ( unsigned long )
       void usleep ( unsigned long )


DESCRIPTION

       The QThread class provides platform-independent threads

       A QThread represents a separate thread of control within
       the program; it shares all data with other threads within
       the process but executes independently in the way that a
       separate program does on a multitasking operating system.
       Instead of starting in main(), however, QThreads begin
       executing in run(), which you inherit to provide your
       code. For instance:

         class MyThread : public QThread {
         public:
           virtual void run();
         };
         void MyThread::run()
         {
           for(int count=0;count<20;count++) {
             sleep(1);
             qDebug("Ping!");
           }
         }
         int main()
         {
             MyThread a;

             a.start();
             b.start();
             a.wait();
             b.wait();
         }

       This will start two threads, each of which writes Ping! 20
       times to the screen and exits. The wait() calls at the end
       of main() are necessary because exiting main() ends the
       program, unceremoniously killing all other threads. Each
       MyThread stops executing when it reaches the end of
       MyThread::run(), just as an application does when it
       leaves main().

       See also the paragraph on Thread Support in Qt


MEMBER FUNCTION DOCUMENTATION


QThread::QThread ()

       Constructs a new thread. The thread does not actually
       begin executing until start() is called.


QThread::~QThread () [virtual]

       QThread destructor. Note that deleting a QThread object
       will not stop the execution of the thread it represents,
       and that deleting a QThread object while the thread is
       running is unsafe.


HANDLE QThread::currentThread () [static]

       This returns the thread handle of the currently executing
       thread. The handle returned by this function is used for
       internal reasons and should not be used in any application
       code. On Windows, the returned value is a pseudo handle
       for the current thread, and it can not be used for
       numerical comparison.


void QThread::exit () [static]

       Ends execution of the calling thread and wakes up any
       threads waiting for its termination.


bool QThread::finished () const

       Returns TRUE is the thread is finished.


void QThread::msleep ( unsigned long msecs ) [static protected]

       System independent sleep. This causes the current thread
       to sleep for msecs milliseconds.


void QThread::postEvent ( QObject * receiver, QEvent * event )

       [static]
       Provides a way of posting an event from a thread which is
       not the event thread to an object. The event is put into a
       queue, then the event thread is woken which then sends the
       event to the object. It is important to note that the
       event handler for the event, when called, will be called

       QThread::postEvent().

       Same as with QApplication::postEvent(), event must be
       allocated on the heap, as it is deleted when the event has
       been posted.


void QThread::run () [virtual protected]

       This method is pure virtual, and it must be implemented in
       derived classes in order to do useful work. Returning from
       this method will end execution of the thread.


bool QThread::running () const

       Returns TRUE if the thread is running.


void QThread::sleep ( unsigned long secs ) [static protected]

       System independent sleep. This causes the current thread
       to sleep for secs seconds.


void QThread::start ()

       This begins actual execution of the thread by calling
       run(), which should be reimplemented in a QThread subclass
       to contain your code. If you try to start a thread that is
       already running, this call will wait until the thread has
       finished, and then restart the thread.


void QThread::usleep ( unsigned long usecs ) [static protected]

       System independent sleep. This causes the current thread
       to sleep for usecs microseconds.


bool QThread::wait ( unsigned long time = ULONG_MAX )

       This allows similar functionality to POSIX pthread_join. A
       thread calling this will block until one of 2 conditions
       is met:

       The thread associated with this QThread object has
              finished execution (i.e. when it returns from run()
              ). This function will return TRUE if the thread has
              finished. It also returns TRUE if the thread has
              not been started yet.

        time milliseconds has elapsed.  If time is ULONG_MAX
              (default
              argument), then the wait will never timeout (the
              thread must return from run() ).  This function
              will return FALSE if the wait timed out.


SEE ALSO

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


COPYRIGHT

       Copyright 1992-2001 Trolltech AS,
       http://www.trolltech.com.  See the license file included



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 (qthread.3qt)
       and the Qt version (2.3.1).


Man(1) output converted with man2html