Kwave::WorkerThread Class Reference

#include <WorkerThread.h>

Inheritance diagram for Kwave::WorkerThread:

Collaboration diagram for Kwave::WorkerThread:

Public Member Functions
	WorkerThread (Kwave::Runnable *runnable, QVariant params)
virtual	~WorkerThread () Q_DECL_OVERRIDE
virtual void	start ()
virtual int	stop (unsigned int timeout=10000)
virtual void	run () Q_DECL_OVERRIDE
virtual void	cancel ()
bool	shouldStop ()

Private Attributes
Kwave::Runnable *	m_runnable
QVariant	m_params
QMutex	m_lock
QMutex	m_lock_sighup
QAtomicInt	m_should_stop
pthread_t	m_tid
pthread_t	m_owner_tid

Detailed Description

Definition at line 35 of file WorkerThread.h.

Constructor & Destructor Documentation

WorkerThread()

Kwave::WorkerThread::WorkerThread ( Kwave::Runnable *  runnable, QVariant  params  )

explicit

Constructor

Definition at line 51 of file WorkerThread.cpp.

References _dummy_SIGHUP_handler(), and g_signal_handler_is_in_place.

    :QThread(Q_NULLPTR),
     m_runnable(runnable),
     m_params(params),
     m_lock(), m_lock_sighup(),
     m_should_stop(0),
     m_tid(pthread_self()),
     m_owner_tid(pthread_self())
{
    /* NOTE: we assume that this gets called from the GUI thread only */
    Q_ASSERT(this->thread() == QThread::currentThread());
    Q_ASSERT(this->thread() == qApp->thread());

    /* install handler for SIGHUP */
    if (!g_signal_handler_is_in_place) {
        /*
         * NOTE: the old signal handler is lost. But as long as we do not use
         *       SIGHUP in any other place of the application and we need to
         *       have a dummy handler only, that should not matter
         */
        signal(SIGHUP, _dummy_SIGHUP_handler);
        g_signal_handler_is_in_place = true;
    }
}

Here is the call graph for this function:

~WorkerThread()

Kwave::WorkerThread::~WorkerThread ( )

virtual

Destructor, calls stop() if the thread is still running.

Definition at line 77 of file WorkerThread.cpp.

References stop().

{
    if (isRunning()) {
        qDebug("WorkerThread::~WorkerThread(): waiting for normal shutdown");
        wait(2000);
        qDebug("WorkerThread::~WorkerThread(): stopping");
        stop(2000);
    }
    Q_ASSERT(!isRunning());
}

Here is the call graph for this function:

Member Function Documentation

cancel()

void Kwave::WorkerThread::cancel ( )

virtual

Sets an internal flag that signals the worker thread to cancel, so that the next call to "shouldStop()" returns true.

Definition at line 176 of file WorkerThread.cpp.

References m_should_stop.

Referenced by Kwave::PlayBackPulseAudio::disconnectFromServer(), Kwave::RecordPulseAudio::disconnectFromServer(), Kwave::PlaybackController::run_wrapper(), and Kwave::PlaybackController::stopDevicePlayBack().

{
    m_should_stop = 1;
}

Here is the caller graph for this function:

run()

void Kwave::WorkerThread::run ( )

virtual

A wrapper for the run() function, calls the run_wrapper(...) of m_runnable with the parameters passed in the constructor.

Reimplemented in Kwave::RecordThread.

Definition at line 154 of file WorkerThread.cpp.

References m_lock_sighup, m_owner_tid, m_params, m_runnable, m_tid, and Kwave::Runnable::run_wrapper().

{
    Q_ASSERT(m_runnable);
    if (!m_runnable) return;

    /* get the POSIX thread ID, needed for sending SIGHUP */
    {
        QMutexLocker _lock(&m_lock_sighup);
        m_tid = pthread_self();
    }

    /* call the run(...) function */
    m_runnable->run_wrapper(m_params);

    /* avoid sending any SIGHUP by setting the m_tid to "invalid" */
    {
        QMutexLocker _lock(&m_lock_sighup);
        m_tid = m_owner_tid;
    }
}

Here is the call graph for this function:

shouldStop()

bool Kwave::WorkerThread::shouldStop

(

)

Returns true if the thread should stop. Should be polled by the thread's run() function to wait for a termination signal.

Definition at line 182 of file WorkerThread.cpp.

References m_should_stop.

Referenced by Kwave::RecordThread::run(), and Kwave::PlaybackController::run_wrapper().

{
    return (m_should_stop);
}

Here is the caller graph for this function:

start()

void Kwave::WorkerThread::start ( )

virtual

Starts the thread's execution.

Definition at line 89 of file WorkerThread.cpp.

References m_lock, and m_should_stop.

Referenced by Kwave::PlayBackPulseAudio::connectToServer(), Kwave::RecordPulseAudio::connectToServer(), Kwave::Plugin::execute(), Kwave::RecordPlugin::leaveInhibit(), and Kwave::PlaybackController::startDevicePlayBack().

{
    QMutexLocker lock(&m_lock);

    // reset the "should stop" command flag
    m_should_stop = 0;

    QThread::start();
}

Here is the caller graph for this function:

stop()

int Kwave::WorkerThread::stop ( unsigned int  timeout = 10000 )

virtual

Stops the thread execution. Please note that you MUST call this function at the end if you derived a class from this one.

Parameters

timeout

the timeout in milliseconds, default = 10s

Returns

zero if successful or an error code if failed

See also

errno.h

Definition at line 100 of file WorkerThread.cpp.

References m_lock, m_lock_sighup, m_owner_tid, m_should_stop, m_tid, and MAX_ATTEMPTS_TO_STOP.

Referenced by Kwave::PlayBackPulseAudio::disconnectFromServer(), Kwave::RecordPulseAudio::disconnectFromServer(), Kwave::RecordPlugin::enterInhibit(), Kwave::RecordPlugin::setup(), Kwave::RecordPlugin::setupRecordThread(), Kwave::Plugin::stop(), Kwave::Plugin::~Plugin(), Kwave::RecordThread::~RecordThread(), and ~WorkerThread().

{
    QMutexLocker lock(&m_lock);
    if (!isRunning()) return 0; // already down

    if (timeout < 1000) timeout = 1000;

    // set the "should stop" flag
    m_should_stop = 1;

    // send one SIGHUP in advance
    {
        QMutexLocker _lock(&m_lock_sighup);
        if (!pthread_equal(m_tid, m_owner_tid))
            pthread_kill(m_tid, SIGHUP);
        if (!isRunning()) return 0;
    }

    // try to stop cooperatively
    if (!isRunning()) return 0;
    wait(timeout/10);
    if (!isRunning()) return 0;

    // try to interrupt by HUP signal
    qWarning("WorkerThread::stop(): sending SIGHUP");
    for (unsigned int i = 0; i < MAX_ATTEMPTS_TO_STOP; i++) {
        {
            QMutexLocker _lock(&m_lock_sighup);
            if (!isRunning()) return 0;
            if (!pthread_equal(m_tid, m_owner_tid))
                pthread_kill(m_tid, SIGHUP);
        }
        if (!isRunning()) return 0;
        wait(timeout/10);
        if (!isRunning()) return 0;
    }

#ifdef DEBUG_FIND_DEADLOCKS
    if (running()) {
        qDebug("WorkerThread::stop(): pthread_self()=%08X",
               (unsigned int)pthread_self());
        void *buf[256];
        size_t n = backtrace(buf, 256);
        backtrace_symbols_fd(buf, n, 2);
    }
#endif

    qDebug("WorkerThread::stop(): canceling thread");
    terminate();

    return -1;
}

Here is the caller graph for this function:

Member Data Documentation

m_lock

QMutex Kwave::WorkerThread::m_lock

private

Mutex to control access to the thread itself

Definition at line 86 of file WorkerThread.h.

Referenced by start(), and stop().

m_lock_sighup

QMutex Kwave::WorkerThread::m_lock_sighup

private

Mutex for protecting SIGHUP <-> thread exit

Definition at line 89 of file WorkerThread.h.

Referenced by run(), and stop().

m_owner_tid

pthread_t Kwave::WorkerThread::m_owner_tid

private

POSIX compatible thread ID of the owner thread.

Definition at line 102 of file WorkerThread.h.

Referenced by run(), and stop().

m_params

QVariant Kwave::WorkerThread::m_params

private

parameter pointer passed to the run() function

Definition at line 83 of file WorkerThread.h.

Referenced by run().

m_runnable

Kwave::Runnable* Kwave::WorkerThread::m_runnable

private

pointer to the object that has a run() function

Definition at line 80 of file WorkerThread.h.

Referenced by run().

m_should_stop

QAtomicInt Kwave::WorkerThread::m_should_stop

private

set to 1 to signal the thread that it should stop

Definition at line 92 of file WorkerThread.h.

Referenced by cancel(), shouldStop(), start(), and stop().

m_tid

pthread_t Kwave::WorkerThread::m_tid

private

POSIX compatible thread ID of the worker thread. only needed and only valid while the thread is running. (needs a POSIX 1003.1-2001 system libc)

Definition at line 99 of file WorkerThread.h.

Referenced by run(), and stop().

---

The documentation for this class was generated from the following files:

• libkwave/WorkerThread.h
• libkwave/WorkerThread.cpp