From aeefd3fe454bfaed093355278b1e2caa84bfd77a Mon Sep 17 00:00:00 2001 From: Michele Calgaro Date: Sun, 30 Jun 2024 12:33:25 +0900 Subject: Rename threading nt* related files to equivalent tq* Signed-off-by: Michele Calgaro --- doc/html/ntqthread.html | 247 ------------------------------------------------ 1 file changed, 247 deletions(-) delete mode 100644 doc/html/ntqthread.html (limited to 'doc/html/ntqthread.html') diff --git a/doc/html/ntqthread.html b/doc/html/ntqthread.html deleted file mode 100644 index edd77b60b..000000000 --- a/doc/html/ntqthread.html +++ /dev/null @@ -1,247 +0,0 @@ - - - - - -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 <ntqthread.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 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 );
-            tqDebug( "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::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.3