{    Q_D(QThread);    QMutexLocker locker(&d->mutex);    if (d->running)        return;    d->running = true;    d->finished = false;    d->terminated = false;    pthread_attr_t attr;    pthread_attr_init(&attr);    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);    d->priority = priority;#if defined(Q_OS_DARWIN) || !defined(Q_OS_OPENBSD) && defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && (_POSIX_THREAD_PRIORITY_SCHEDULING-0 >= 0)    switch (priority) {    case InheritPriority:        {            pthread_attr_setinheritsched(&attr, PTHREAD_INHERIT_SCHED);            break;        }    default:        {            int sched_policy;            if (pthread_attr_getschedpolicy(&attr, &sched_policy) != 0) {                // failed to get the scheduling policy, don't bother                // setting the priority                qWarning("QThread::start: Cannot determine default scheduler policy");                break;            }            int prio_min = sched_get_priority_min(sched_policy);            int prio_max = sched_get_priority_max(sched_policy);            if (prio_min == -1 || prio_max == -1) {                // failed to get the scheduling parameters, don't                // bother setting the priority                qWarning("QThread::start: Cannot determine scheduler priority range");                break;            }            int prio;            switch (priority) {            case IdlePriority:                prio = prio_min;                break;            case TimeCriticalPriority:                prio = prio_max;                break;            default:                // crudely scale our priority enum values to the prio_min/prio_max                prio = (((prio_max - prio_min) / TimeCriticalPriority) * priority) + prio_min;                prio = qMax(prio_min, qMin(prio_max, prio));                break;            }            sched_param sp;            sp.sched_priority = prio;            pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);            pthread_attr_setschedparam(&attr, &sp);            break;        }    }#endif // _POSIX_THREAD_PRIORITY_SCHEDULING    if (d->stackSize > 0) {#if defined(_POSIX_THREAD_ATTR_STACKSIZE) && (_POSIX_THREAD_ATTR_STACKSIZE-0 > 0)        int code = pthread_attr_setstacksize(&attr, d->stackSize);#else        int code = ENOSYS; // stack size not supported, automatically fail#endif // _POSIX_THREAD_ATTR_STACKSIZE        if (code) {            qWarning("QThread::start: Thread stack size error: %s",                     qPrintable(qt_error_string(code)));            // we failed to set the stacksize, and as the documentation states,            // the thread will fail to run...            d->running = false;            d->finished = false;            return;        }    }    int code =        pthread_create(&d->thread_id, &attr, QThreadPrivate::start, this);    if (code == EPERM) {        // caller does not have permission to set the scheduling        // parameters/policy        pthread_attr_setinheritsched(&attr, PTHREAD_INHERIT_SCHED);        code =            pthread_create(&d->thread_id, &attr, QThreadPrivate::start, this);    }    pthread_attr_destroy(&attr);    if (code) {        qWarning("QThread::start: Thread creation error: %s", qPrintable(qt_error_string(code)));        d->running = false;        d->finished = false;        d->thread_id = 0;    }}/*!    Terminates the execution of the thread. The thread may or may not    be terminated immediately, depending on the operating systems    scheduling policies. Use QThread::wait() after terminate() for    synchronous termination.    When the thread is terminated, all threads waiting for the thread    to finish will be woken up.    \warning This function is dangerous and its use is discouraged.    The thread can be terminate 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.    Termination can be explicitly enabled or disabled by calling    QThread::setTerminationEnabled(). Calling this function while    termination is disabled results in the termination being    deferred, until termination is re-enabled. See the documentation    of QThread::setTerminationEnabled() for more information.    \sa setTerminationEnabled()*/void QThread::terminate(){    Q_D(QThread);    QMutexLocker locker(&d->mutex);    if (!d->thread_id)        return;    int code = pthread_cancel(d->thread_id);    if (code) {        qWarning("QThread::start: Thread termination error: %s",                 qPrintable(qt_error_string((code))));    } else {        d->terminated = true;    }}/*!    Blocks the thread until either of these conditions is met:    \list    \o The thread associated with this QThread object has finished       execution (i.e. when it returns from \l{run()}). This function       will return true if the thread has finished. It also returns       true if the thread has not been started yet.    \o \a time milliseconds has elapsed. If \a time is ULONG_MAX (the        default), then the wait will never timeout (the thread must        return from \l{run()}). This function will return false if the        wait timed out.    \endlist    This provides similar functionality to the POSIX \c    pthread_join() function.    \sa sleep(), terminate()*/bool QThread::wait(unsigned long time){    Q_D(QThread);    QMutexLocker locker(&d->mutex);    if (d->thread_id == pthread_self()) {        qWarning("QThread::wait: Thread tried to wait on itself");        return false;    }    if (d->finished || !d->running)        return true;    while (d->running) {        if (!d->thread_done.wait(locker.mutex(), time))            return false;    }    return true;}/*!    Enables or disables termination of the current thread based on the    \a enabled parameter. The thread must have been started by    QThread.    When \a enabled is false, termination is disabled.  Future calls    to QThread::terminate() will return immediately without effect.    Instead, the termination is deferred until termination is enabled.    When \a enabled is true, termination is enabled.  Future calls to    QThread::terminate() will terminate the thread normally.  If    termination has been deferred (i.e. QThread::terminate() was    called with termination disabled), this function will terminate    the calling thread \e immediately.  Note that this function will    not return in this case.    \sa terminate()*/void QThread::setTerminationEnabled(bool enabled){    Q_ASSERT_X(currentThread() != 0, "QThread::setTerminationEnabled()",               "Current thread was not started with QThread.");    pthread_setcancelstate(enabled ? PTHREAD_CANCEL_ENABLE : PTHREAD_CANCEL_DISABLE, NULL);    if (enabled)        pthread_testcancel();}void QThread::setPriority(Priority priority){    Q_D(QThread);    QMutexLocker locker(&d->mutex);    if (!d->running) {        qWarning("QThread::setPriority: Cannot set priority, thread is not running");        return;    }    d->priority = priority;    // copied from start() with a few modifications:#if defined(Q_OS_DARWIN) || !defined(Q_OS_OPENBSD) && defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && (_POSIX_THREAD_PRIORITY_SCHEDULING-0 >= 0)    int sched_policy;    sched_param param;    if (pthread_getschedparam(d->thread_id, &sched_policy, &param) != 0) {        // failed to get the scheduling policy, don't bother setting        // the priority        qWarning("QThread::setPriority: Cannot get scheduler parameters");        return;    }    int prio_min = sched_get_priority_min(sched_policy);    int prio_max = sched_get_priority_max(sched_policy);    if (prio_min == -1 || prio_max == -1) {        // failed to get the scheduling parameters, don't        // bother setting the priority        qWarning("QThread::setPriority: Cannot determine scheduler priority range");        return;    }    int prio;    switch (priority) {    case InheritPriority:        qWarning("QThread::setPriority: Argument cannot be InheritPriority");        return;    case IdlePriority:        prio = prio_min;        break;    case TimeCriticalPriority:        prio = prio_max;        break;    default:        // crudely scale our priority enum values to the prio_min/prio_max        prio = (((prio_max - prio_min) / TimeCriticalPriority) * priority) + prio_min;        prio = qMax(prio_min, qMin(prio_max, prio));        break;    }    param.sched_priority = prio;    pthread_setschedparam(d->thread_id, sched_policy, &param);#endif}#endif // QT_NO_THREAD