void cStreamManager::OpenStream()
{
    mStream->OpenStream();
    boost::thread StreamThread(boost::bind(&cStream::Play, mStream));

    StreamThread.join();

    return;
}

void cStreamManager::CloseStream()
{
    mStream->CloseStream();

    return;
}

Die Funktion OpenStream() wartet durch StreamThread.join(); auf das Ende von
cStream::Play(). Der Mainthread wurde also angehalten. Von ihm aus kann dann
aber für das Objekt der Klasse cStreamManager keine weitere Methode, z. B.
CloseStream(), mehr aufgerufen werden. Diese Methode würde cStream::Play()
beenden. Das wird aber nie erreicht.
Was mach ich falsch?

Was mach ich falsch?

Vermutlich das join(). Welchen Sinn macht es, einen neuen Thread zu starten und den alten sofort anzuhalten, bis der neue fertig ist?

Der Mainthread soll sich ja nicht beenden.

Er wird ja auch nicht beendet. Die Ausführung wird nur unterbrochen bis der andere Thread fertig ist. AFAIK ist das doch der Sinn von join oder nicht? Das heißt du kommst aus der OpenStream()-Methode erst wieder raus wenn Play() beendet wurde und der erzeugte Thread mit der Ausführung fertig ist.

Noch was anderes. Ist folgendes möglich?
Ich übergebe der Threadfunktion, die eine Methode einer anderen Klasse ist,
eine Referenz auf den Mutex.

Ein Mutex steht immer in Beziehung zu einem Datum. Folglich sollte das Mutex ein Member derselben Klasse sein, die auch das zu schützende Datum enthält. Eine Übergabe des Mutex ist unüblich.

mase schrieb:

Bevor ich den Thread erstelle, sperre ich den Muxex mit mutex.lock().
Die Threadfunktion beginnt mit mutex.lock() gefolgt von mutex.unlock(), dann
die weiteren Anweisungen. Sie soll also erst einmal warten.
Die Threadfunktion soll jetzt erst die weiteren Anweisungen ausführen, wenn
im Mainthread der Mutex mittels mutex.unlock() freigegeben wird.
Der Sinn ist, es soll der Thread erstellt werden, er soll aber trotzdem
warten, bis noch ein paar set-Funktionen ausgeführt wurden, um ihn zu
initialisieren.
Es soll so auch möglich sein, den Thread an verschiedenen Stellen zu
pausieren.

.. dafür ein Mutex mit gegenseitigem Lock zu nutzen ist ebenso ungewöhnlich.

Dafür nimmt man i.A. die Condition. Bei Dir vielleicht in Kombination mit einem einfachen Flag (bool), welches angibt, ob der Thread (Play) angehalten wird oder nicht (Member m_pause - s.Code unten).

Zunächst einmal würde ich den Thread zum Member der Klasse machen, auf deren Daten der Thread zugreift. Ich unterstelle mal, dass im wesentlichen Informationen des 'cStream' benötigt werden. Also sollte der Thread Member von dieser Klasse sein; entweder direkt oder als Pointer.

Das Play und Pause(mit der Möglichkeit zum Fortfahren) kann dann über eine einfache bool-Variable in Kombination mit der condition erreicht werden. Als Code-Skizze sähe das so aus:

class cStream
{
public:
    typedef boost::mutex::scoped_lock lock_type;

    cStream() 
        : m_running( true )
        , m_pause( true )
        , m_condition()
        , m_mtx()
        , m_thrd( boost::bind( &cStream::Run, this ) ) // Bem.: warning wg. Zugriff auf 'this' ist ok, solange m_thrd letztes Element in cStream ist!
    {}
    ~cStream()
    {
        m_running = false; // beendet Schleife in Run-Methode
        Play(); // sicherstellen, dass der Thread nicht in der Pause fest hängt
        m_thrd.join(); // warte, bis Thread zu Ende ist
    }

    void Play()
    {
        lock_type lock( m_mtx );
        m_pause = false;
        m_condition.notify_one(); // weckt ggf. die wait-Methode
    }
    void Pause()
    {
        lock_type lock( m_mtx );
        m_pause = true;
    }

private:
    void Run()  // hier rennt der Thread; Methoden-Ende ist auch Thread-Ende
    {
        for( ; m_running; )
        {
            check4pause();  // blockiert wenn 'm_pause == true' (s.u.)
            // .. Stream abspielen
        }
    }
    void check4pause()
    {
        lock_type lock( m_mtx );
        while( m_pause )
        {
            m_condition.wait( lock ); // blockiert bis 'notify'
        }
    }

    // --   Member
    bool m_running;
    bool m_pause;
    boost::condition_variable m_condition;
    boost::mutex m_mtx;
    boost::thread m_thrd;
};

Gruß
Werner

Gruß
Werner

Du meinst, dass der Stream in der Lockzeit nicht abreisst?

ich dachte eher daran, dass man von außen Pause() aufruft und der cStream mehr oder weniger unmittelbar reagiert, ohne erst das ganze aktuelle Lied abzuspielen - aus was für Einheiten besteht denn so eine 'PlayList' und wie lange dauert das Abspielen so einer Einheit?

mase schrieb:

Ich habe mir überlegt, das über einen vector von buffern zu machen (FIFO).
Aber ist das in meinem Fall ok, den Mutex im Mainthread zu erzeugen und
an beide Klassen zu übergeben?

Kann ich so pauschal nicht sagen. Ein Mutex ist nach meinem Verständnis dafür nicht gemacht ...

mase schrieb:

Mit dem separaten Mutex erreiche ich aber auch, dass ich während der Pause-
phase die Playlist modifizieren kann. Das wäre mit einem gemeinsamen wohl
nicht möglich.

Sicher - warum sollte das nicht möglich sein. Lasse Dich von dem Lock in 'check4pause' nicht beirren. Innerhalb von condition::wait wird der lock wieder geöffnet, sonst würde der Play ja auch nicht funktionieren.

mase schrieb:

Aber deine Methode funktioniert tatsächlich.
In meiner Boost-Doku steht gar nix von mutex::scoped_lock und notify_one().

guckst Du hier: mutex::scoped_lock & notify_one()

Gruß
Werner

Hauptprogramm

int main()
{
    cStream *Stream = new cStream(true);

    Stream->OpenStream();
    Stream->StartStream();

    boost::this_thread::sleep(boost::posix_time::seconds(5));
    Stream->PauseStream(true);

    delete Stream;
}

Klasse cStream

void cStream::PauseStream(bool _Pause)
{
    if (mPause == _Pause)
    {
        return;
    }

    if (!_Pause)
    {
        boost::mutex::scoped_lock Pause(mPauseMutex);

        mPause = false;
        mPauseCondition.notify_one();

        return;
    }

    boost::mutex::scoped_lock Pause(mPauseMutex);

    mPause = true;

    return;
}

int cStream::OpenStream()
{
   //Hier wird die Serververbindung hergestellt
}

void cStream::StartStream()
{
    boost::thread StreamThread(boost::bind(&cStream::Send, this));
}

void cStream::CheckPause()
{
    boost::mutex::scoped_lock Pause(mPauseMutex);

    while (mPause)
    {
        mPauseCondition.wait(Pause);
    }
}

void cStream::Send()
{
        while (!mStop)
    {
        //pause stream?
        CheckPause();
        //Jetzt werden weitere Funktionen zum Bufferfüllen und Abspielen
        //aufgerufen
    }
}

void cStream::StopStream()
{
    mStop = true;

    PauseStream(false);

    return;
}

Alle Variablen, die mit m beginnen sind als Member in der Headerdatei
deklariert.
In der Funktion cStream::StopStream() musste ich zuerst die Pause aufheben,
sonst stürzt das Programm an dieser Stelle ab.
Mein Problem ist jetzt, dass wenn länger als ca. 10 Sekunden pausiert und dann
die Pause aufgehoben wurde, sich das Programm ohne Fehler beendet.
Es existiert auch kein Servertimeout.
Ich kann mir nicht erklären, warum das so ist.

Das Programm hat das Signal SIGPIPE (Broken pipe) empfangen.

Das ganze immer beim zweiten Sendeblock. Und von libshout kommt keine
Fehlermeldung zurück. Pausiere ich nur 5 Sekunden, läuft alles problemlos.