From d796c9dd933ab96ec83b9a634feedd5d32e1ba3f Mon Sep 17 00:00:00 2001 From: Timothy Pearson Date: Tue, 8 Nov 2011 12:31:36 -0600 Subject: Test conversion to TQt3 from Qt3 8c6fc1f8e35fd264dd01c582ca5e7549b32ab731 --- doc/html/qthread.html | 252 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 252 insertions(+) create mode 100644 doc/html/qthread.html (limited to 'doc/html/qthread.html') diff --git a/doc/html/qthread.html b/doc/html/qthread.html new file mode 100644 index 000000000..ac75c3ad7 --- /dev/null +++ b/doc/html/qthread.html @@ -0,0 +1,252 @@ + + + + + +TQThread Class + + + + + + + +

TQThread Class Reference

+ +

The TQThread class provides platform-independent threads. +More... +

All the functions in this class are thread-safe when TQt is built with thread support.

#include <qthread.h> +

Inherits TQt. +

List of all member functions. +

Public Members

TQThread ( unsigned int stackSize = 0 )
virtual ~TQThread ()
bool wait ( unsigned long time = ULONG_MAX )
enum Priority { IdlePriority, LowestPriority, LowPriority, NormalPriority, HighPriority, HighestPriority, TimeCriticalPriority, InheritPriority }
void start ( Priority priority = InheritPriority )
void terminate ()
bool finished () const
bool running () const

Static Public Members

TQt::HANDLE currentThread ()
void postEvent ( TQObject * receiver, TQEvent * event ) (obsolete)
void exit ()

Protected Members

virtual void run () = 0

Static Protected Members

void sleep ( unsigned long secs )
void msleep ( unsigned long msecs )
void usleep ( unsigned long usecs )

Detailed Description

+ + + +The TQThread class provides platform-independent threads. +

+ +

A TQThread represents a separate thread of control within the +program; it shares data with all the 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(), TQThreads begin executing in run(). You inherit +run() to include your code. For example: +

+    class MyThread : public TQThread {
+
+    public:
+
+        virtual void run();
+
+    };
+
+    void MyThread::run()
+    {
+        for( int count = 0; count < 20; count++ ) {
+            sleep( 1 );
+            qDebug( "Ping!" );
+        }
+    }
+
+    int main()
+    {
+        MyThread a;
+        MyThread b;
+        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 Thread Support in TQt, Environment Classes, and Threading. + +

Member Type Documentation

TQThread::Priority

+ +

This enum type indicates how the operating system should schedule +newly created threads. +

TQThread::IdlePriority - scheduled only when no other threads are +running. +
TQThread::LowestPriority - scheduled less often than LowPriority. +
TQThread::LowPriority - scheduled less often than NormalPriority. +
TQThread::NormalPriority - the default priority of the operating +system. +
TQThread::HighPriority - scheduled more often than NormalPriority. +
TQThread::HighestPriority - scheduled more often then HighPriority. +
TQThread::TimeCriticalPriority - scheduled as often as possible. +
TQThread::InheritPriority - use the same priority as the creating +thread. This is the default. +

Member Function Documentation

TQThread::TQThread ( unsigned int stackSize = 0 ) +

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

If stackSize is greater than zero, the maximum stack size is +set to stackSize bytes, otherwise the maximum stack size is +automatically determined by the operating system. +

Warning: Most operating systems place minimum and maximum limits +on thread stack sizes. The thread will fail to start if the stack +size is outside these limits. + +

TQThread::~TQThread () `[virtual]` +

+TQThread destructor. +

Note that deleting a TQThread object will not stop the execution of +the thread it represents. Deleting a running TQThread (i.e. +finished() returns FALSE) will probably result in a program crash. +You can wait() on a thread to make sure that it has finished. + +

TQt::HANDLE TQThread::currentThread () `[static]` +

+This returns the thread handle of the currently executing thread. +

Warning: The handle returned by this function is used for internal +purposes and should not be used in any application code. On +Windows, the returned value is a pseudo handle for the current +thread, and it cannot be used for numerical comparison. + +

void TQThread::exit () `[static]` +

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

bool TQThread::finished () const +

+Returns TRUE if the thread is finished; otherwise returns FALSE. + +

void TQThread::msleep ( unsigned long msecs ) `[static protected]` +

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

void TQThread::postEvent ( TQObject * receiver, TQEvent * event ) `[static]` +

This function is obsolete. It is provided to keep old source working. We strongly advise against using it in new code. +

Use TQApplication::postEvent() instead. + +

void TQThread::run () `[pure virtual protected]` +

+ +

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

bool TQThread::running () const +

+Returns TRUE if the thread is running; otherwise returns FALSE. + +

void TQThread::sleep ( unsigned long secs ) `[static protected]` +

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

void TQThread::start ( Priority priority = InheritPriority ) +

+Begins execution of the thread by calling run(), which should be +reimplemented in a TQThread subclass to contain your code. The +operating system will schedule the thread according to the priority argument. +

If you try to start a thread that is already running, this +function will wait until the the thread has finished and then +restart the thread. +

void TQThread::terminate () +

+This function terminates the execution of the thread. The thread +may or may not be terminated immediately, depending on the +operating system's scheduling policies. Use TQThread::wait() +after terminate() for synchronous termination. +

When the thread is terminated, all threads waiting for the +the thread to finish will be woken up. +

Warning: This function is dangerous, and its use is discouraged. +The thread can be terminated at any point in its code path. Threads +can be terminated while modifying data. There is no chance for +the thread to cleanup after itself, unlock any held mutexes, etc. +In short, use this function only if absolutely necessary. + +

void TQThread::usleep ( unsigned long usecs ) `[static protected]` +

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

bool TQThread::wait ( unsigned long time = ULONG_MAX ) +

+A thread calling this function will block until either of these +conditions is met: +

The thread associated with this TQThread 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 (the +default), then the wait will never timeout (the thread must +return from run()). This function will return FALSE if the +wait timed out. +

This provides similar functionality to the POSIX pthread_join() function. + + +

+ +

Trademarks +

TQt 3.3.8

+ -- cgit v1.2.1