qthread_win.cpp File Reference

#include "qthread.h"
#include "qthread_p.h"
#include "qthreadstorage.h"
#include "qmutex.h"
#include <qcoreapplication.h>
#include <qpointer.h>
#include <private/qcoreapplication_p.h>
#include <private/qeventdispatcher_win_p.h>
#include <qt_windows.h>
#include "qfunctions_wince.h"

Go to the source code of this file.

Macros
#define	_WIN32_WINNT   0x0400

Functions
DWORD WINAPI	qt_adopted_thread_watcher_function (LPVOID)
	This function loops and waits for native adopted threads to finish. More...
void	qt_create_tls ()
	Initializes the QThread system. More...
static void	qt_free_tls ()
void	qt_watch_adopted_thread (const HANDLE adoptedThreadHandle, QThread *qthread)
	Adds an adopted thread to the list of threads that Qt watches to make sure the thread data is properly cleaned up. More...

Variables
static QVector< QThread * >	qt_adopted_qthreads
static QVector< HANDLE >	qt_adopted_thread_handles
static HANDLE	qt_adopted_thread_wakeup = 0
static DWORD	qt_adopted_thread_watcher_id = 0
static QMutex	qt_adopted_thread_watcher_mutex
static DWORD	qt_current_thread_data_tls_index = TLS_OUT_OF_INDEXES

Macro Definition Documentation

_WIN32_WINNT

#define _WIN32_WINNT   0x0400

Definition at line 44 of file qthread_win.cpp.

Function Documentation

qt_adopted_thread_watcher_function()

DWORD WINAPI qt_adopted_thread_watcher_function

(

LPVOID

)

This function loops and waits for native adopted threads to finish.

Warning

This function is not part of the public interface.

When this happens it derefs the QThreadData for the adopted thread to make sure it gets cleaned up properly.

Definition at line 211 of file qthread_win.cpp.

Referenced by qt_watch_adopted_thread().

{
    forever {
        qt_adopted_thread_watcher_mutex.lock();

        if (qt_adopted_thread_handles.count() == 1) {
            qt_adopted_thread_watcher_id = 0;
            qt_adopted_thread_watcher_mutex.unlock();
            break;
        }

        QVector<HANDLE> handlesCopy = qt_adopted_thread_handles;
        qt_adopted_thread_watcher_mutex.unlock();

        DWORD ret = WAIT_TIMEOUT;
        int count;
        int offset;
        int loops = handlesCopy.size() / MAXIMUM_WAIT_OBJECTS;
        if (handlesCopy.size() % MAXIMUM_WAIT_OBJECTS)
            ++loops;
        if (loops == 1) {
            // no need to loop, no timeout
            offset = 0;
            count = handlesCopy.count();
            ret = WaitForMultipleObjects(handlesCopy.count(), handlesCopy.constData(), false, INFINITE);
        } else {
            int loop = 0;
            do {
                offset = loop * MAXIMUM_WAIT_OBJECTS;
                count = qMin(handlesCopy.count() - offset, MAXIMUM_WAIT_OBJECTS);
                ret = WaitForMultipleObjects(count, handlesCopy.constData() + offset, false, 100);
                loop = (loop + 1) % loops;
            } while (ret == WAIT_TIMEOUT);
        }

        if (ret == WAIT_FAILED || ret >= WAIT_OBJECT_0 + uint(count)) {
            qWarning("QThread internal error while waiting for adopted threads: %d", int(GetLastError()));
            continue;
        }

        const int handleIndex = offset + ret - WAIT_OBJECT_0;
        if (handleIndex == 0){
            // New handle to watch was added.
            continue;
        } else {
//             printf("(qt) - qt_adopted_thread_watcher_function... called\n");
            const int qthreadIndex = handleIndex - 1;

            qt_adopted_thread_watcher_mutex.lock();
            QThreadData *data = QThreadData::get2(qt_adopted_qthreads.at(qthreadIndex));
            qt_adopted_thread_watcher_mutex.unlock();
            if (data->isAdopted) {
                QThread *thread = data->thread;
                Q_ASSERT(thread);
                QThreadPrivate *thread_p = static_cast<QThreadPrivate *>(QObjectPrivate::get(thread));
                Q_ASSERT(!thread_p->finished);
                thread_p->finish(thread);
            }
            data->deref();

            QMutexLocker lock(&qt_adopted_thread_watcher_mutex);
#if !defined(Q_OS_WINCE) || (defined(_WIN32_WCE) && (_WIN32_WCE>=0x600))
            CloseHandle(qt_adopted_thread_handles.at(handleIndex));
#endif
            qt_adopted_thread_handles.remove(handleIndex);
            qt_adopted_qthreads.remove(qthreadIndex);
        }
    }

    QThreadData *threadData = reinterpret_cast<QThreadData *>(TlsGetValue(qt_current_thread_data_tls_index));
    if (threadData)
        threadData->deref();

    return 0;
}

qt_create_tls()

void qt_create_tls

(

)

Initializes the QThread system.

Warning

This function is not part of the public interface.

Definition at line 78 of file qthread_win.cpp.

Referenced by QThread::initialize(), qt_adopted_thread_watcher_function(), and qt_free_tls().

{
    if (qt_current_thread_data_tls_index != TLS_OUT_OF_INDEXES)
        return;
    static QMutex mutex;
    QMutexLocker locker(&mutex);
    qt_current_thread_data_tls_index = TlsAlloc();
}

qt_free_tls()

static void qt_free_tls ( )

static

Definition at line 87 of file qthread_win.cpp.

{
    if (qt_current_thread_data_tls_index != TLS_OUT_OF_INDEXES) {
        TlsFree(qt_current_thread_data_tls_index);
        qt_current_thread_data_tls_index = TLS_OUT_OF_INDEXES;
    }
}

qt_watch_adopted_thread()

void qt_watch_adopted_thread	(	const HANDLE	adoptedThreadHandle,
		QThread *	qthread
	)

Adds an adopted thread to the list of threads that Qt watches to make sure the thread data is properly cleaned up.

Warning

This function is not part of the public interface. This function starts the watcher thread if necessary.

Definition at line 176 of file qthread_win.cpp.

Referenced by qt_free_tls().

{
    QMutexLocker lock(&qt_adopted_thread_watcher_mutex);

    if (GetCurrentThreadId() == qt_adopted_thread_watcher_id) {
#if !defined(Q_OS_WINCE) || (defined(_WIN32_WCE) && (_WIN32_WCE>=0x600))
        CloseHandle(adoptedThreadHandle);
#endif
        return;
    }

    qt_adopted_thread_handles.append(adoptedThreadHandle);
    qt_adopted_qthreads.append(qthread);

    // Start watcher thread if it is not already running.
    if (qt_adopted_thread_watcher_id == 0) {
        if (qt_adopted_thread_wakeup == 0) {
            qt_adopted_thread_wakeup = CreateEvent(0, false, false, 0);
            qt_adopted_thread_handles.prepend(qt_adopted_thread_wakeup);
        }

        CreateThread(0, 0, qt_adopted_thread_watcher_function, 0, 0, &qt_adopted_thread_watcher_id);
    } else {
        SetEvent(qt_adopted_thread_wakeup);
    }
}

Variable Documentation

qt_adopted_qthreads

QVector<QThread *> qt_adopted_qthreads

static

Definition at line 163 of file qthread_win.cpp.

qt_adopted_thread_handles

QVector<HANDLE> qt_adopted_thread_handles

static

Definition at line 162 of file qthread_win.cpp.

Referenced by qt_adopted_thread_watcher_function().

qt_adopted_thread_wakeup

HANDLE qt_adopted_thread_wakeup = 0

static

Definition at line 166 of file qthread_win.cpp.

Referenced by qt_watch_adopted_thread().

qt_adopted_thread_watcher_id

DWORD qt_adopted_thread_watcher_id = 0

static

Definition at line 165 of file qthread_win.cpp.

Referenced by qt_adopted_thread_watcher_function(), and qt_watch_adopted_thread().

qt_adopted_thread_watcher_mutex

QMutex qt_adopted_thread_watcher_mutex

static

Definition at line 164 of file qthread_win.cpp.

qt_current_thread_data_tls_index

DWORD qt_current_thread_data_tls_index = TLS_OUT_OF_INDEXES

static

Definition at line 77 of file qthread_win.cpp.

Referenced by qt_adopted_thread_watcher_function(), qt_create_tls(), and qt_free_tls().