Frage zur Thread-Programmierung mit VDR

würde mich auch gerade interessieren, da ich selbst gerade damit herum experimentiere...

Hi,

ich mach das immer mit einer m_instance static-Variable im thread. Hier aus dem deluxe-Plugin:

Header:

// --- cConvertToAudioThread----------------------------------------------------
class cConvertToAudioThread: public cThread {
    static cRecording* recording;
 protected:
    virtual void Action(void);
 public:
    static cConvertToAudioThread *m_Instance;
    static int progress;


    cConvertToAudioThread(cRecording* Recording);
    virtual ~cConvertToAudioThread();
    static void Init(cRecording* Recording);
    static void Exit(void);
    void Stop(void);
};

Teile der Implementierung:

cConvertToAudioThread *cConvertToAudioThread::m_Instance = NULL;


cConvertToAudioThread::~cConvertToAudioThread() {
    Stop();
}


void cConvertToAudioThread::Init(cRecording* Recording)
{
    if (m_Instance == NULL) {
        m_Instance = new cConvertToAudioThread(Recording);
        m_Instance->Start();
    }
}


void cConvertToAudioThread::Exit(void) {
    if (m_Instance != NULL) {
        m_Instance->Stop();
        DELETENULL(m_Instance);
    }
}


void cConvertToAudioThread::Action(void)
{
// mach was
    m_Instance = NULL;
}

Thread-Start und Prüfung:

if (cConvertToAudioThread::m_Instance)
        cConvertToAudioThread::Exit();
    else
        cConvertToAudioThread::Init(recording);
    return osEnd;
}

Tschüss,

winni

Habe eben ein interessantes Howto zur Thread Programmierung gefunden.

Vieleicht hilft es anderen wenn sie mit ihren fragen zufällig über diesen Beitrag stolpern...

Linux-Magazin - Threads

Gruß,
Thomas

Zitat

Originally posted by nordlicht
Wenn ich mit dem, was dort getan wird, dann fertig bin, Action() also beendet wird, beendet sich dann auch der Thread? Wenn ja, was passiert mit meiner Variable thread?

Der eigentliche Thread ist die statische Methode cThread::StartThread, die dann wiederum cThread::Action aufruft. Nachdem Action beendet wurde, setzt StartThread noch running und active auf false, und beendet sich dann. Damit endet auch die Lebenszeit des eigentlichen Threads.

Das cThread-Objekt ist davon aber unabhängig, und existiert weiterhin. Es ist sogar vorgesehen, dass ein bereits wieder beendeter Thread mit Start() erneut gestartet, und somit recycelt wird.

Das Aufräumen des cThread-Objekts ist die Aufgabe des 'Besitzers' des Threads, in der Regel sollte sich der darum kümmern, der den Thread angelegt hat. Da das Objekt nicht abgeräumt werden kann, so lange der Thread läuft, kann sich der Thread auch nicht selbst entsorgen.

Zitat

Kann ich mit einer Abfrage der Form if(!thread) { feststellen, ob schon ein Thread existiert?

So garantiert nicht, da weder das Objekt noch der Thread etwas von dem thread-Zeiger weiss. Wer sollte thread auf NULL setzen, wenn nicht du selbst?

Um den Thread zu kontrollieren, gibt es cThread::Running() (Thread hat Cancel-Anweisung bekommen, sich zu beenden) und cThread::Active() (Thread läuft derzeit).

Noch ein Hinweis, weil es auf den ersten Blick schlau scheint, aber letztlich keine Lösung ist:
Es bietet sich geradezu an, den Thread über den Destruktor zu beenden, dh. in ~cMyThread() nochmal Cancel() aufzurufen. Sauber ist es aber nicht, da im Thread ja noch auf das Objekt zugegriffen wird. Bei direkt abgeleiteten Thread-Objekten funktioniert das gerade noch, bei zweimaligem Ableiten (cMyThread : public cMyThreadBase, cMyThreadBase : public cThread) geht es dann aber garantiert schief, da der Destruktor u.U. schon Teile des Objekts abgebaut hat, bevor Action() beendet ist. Sicher ist man nur, wenn man sicher stellt, dass Cancel vor dem Destruktor aufgerufen wird:

thread->Cancel();
delete thread;

Zitat

Und dort gibt es eine Abfrage der Form if(!cuttingThread), wobei ich aber nirgends die Stelle finde, wo der Zeiger wieder auf NULL gesetzt wird, wenn der Thread sich beendet hat.

Das Thread-Objekt wird in cCutter::Stop abgebaut. Stop wird wiederum aus cCutter::Active() aufgerufen, nachdem der Thread beendet wurde. cCutter::Active wiederum wird regelmässig aus der Haupuschleife von VDR in vdr.c aufgerufen, unmittelbar bevor "Editing process finished" gemeldet wird.

Gruß,

Udo