boost thread

[*Cpp-Anfänger* 0]

Hallo zusammen,

ich möchte einen ThreadManager schreiben, der alle Threads verwaltet.
Es soll eine einfache std::listboost::thread* sein.

Wenn diesem ThreadManager ein Signal gegeben wird, soll er dafür
sorgen, dass sich alle threads beenden. Hierzu möchte ich in jedem
Thread ein Terminate-Flag setzen, damit dieser sich beendet.
Mein Problem ist allerdings, dass ich nicht weiß, wie ich auf das
Objekt (bzw. seine Kopie) zugreife, das ich dem Konstruktor von boost::thread übergeben habe.
Es wird ja (verständlicherweise) eine Kopie dieses Objektes erstellt.
Wie würdet ihr dieses Problem lösen?
Kan ich einfach von boost::thread erben oder muss ich da irgendwelche Probleme
befürchten?

Viele Grüße und schöne Feiertage,
*Cpp-Anfänger*

[hustbaer]

Ich würde das Problem lösen indem du an boost::thread einen Funktor übergibst den du von boost::bind erhältst, indem du einen shared_ptr auf eine Struktur/Class als "this" Zeiger für einen member-function-pointer bindest.
Ca. so:

struct MyThreadContext
{
    void ThreadFunction()
    {
        for (;;)
        {
            {
                boost::mutex::scoped_lock l(m_mutex);
                if (m_killFlag)
                    break;
            }

            DoSomething();
        }
    }

    void DoSomething()
    {
        // ...
    }

    boost::mutex m_mutex;
    bool m_killFlag;
};

void foo()
{
    boost::shared_ptr<MyThreadContext> context(new MyThreadContext);
    boost::thread th(boost::bind(&MyThreadContext::ThreadFunction, context));

    // ...

    {
        boost::mutex::scoped_lock l(context->m_mutex);
        context->m_killFlag = true;
    }
    th.join();
}

[*Cpp-Anfänger* 0]

Die Lösung gefällt mir sehr gut...

Danke hustbaer!

[*Cpp-Anfänger* 0]

Hi hustbaer,

ich glaub das geht so doch nicht, da boost::shared_ptr nicht thread-safe ist...

Der Zugriff erfolgt ja in 2 verschiedenen Threads, oder nicht?

[The-Kenny]

Cpp-Anfänger schrieb:

Hi hustbaer,

ich glaub das geht so doch nicht, da boost::shared_ptr nicht thread-safe ist...

Der Zugriff erfolgt ja in 2 verschiedenen Threads, oder nicht?

Genau dafür ist der Mutex da
Allerdings müssen noch eventuelle Exceptions usw. abgefangen werden, es ist also eher ein minimalistisches Beispiel. (imho)

[*Cpp-Anfänger* 0]

Danke nochmal für eure Hilfe...

Mir war schon klar, wofür der Mutex ist.
Allerdings in diesem Fall wohl unnötig, da keine Konkurrierenden Schreibzugriffe
stattfinden.
Ich dachte eher an den Moment, wo der Thread beendet wird und
der shared_ptr zerstört wird. Im anderen ursprünglichen Thread besteht aber auch
Zugriff auf den Shared-Pointer.
Naja, der Fehler lag wo anders ^^

Gruß,
*Cpp-Anfänger*

[hustbaer]

boost::shared_ptr ist sehrwohl threadsafe wenn jeder thread seine eigene kopie des zeigers hat. das beide zeiger auf dasselbe objekt zeigen ist dabei egal.
intern verwendet shared_ptr entweder eine eigene mutex um den shared count zu schützen bzw. einfach interlocked funktionen (je nach boost version, die aktuelle verwendet IIRC unter windows die interlocked funktionen, keine ahnung was z.b. unter linux verwendet wird).

die mutex schliesslich hat mit dem shared_ptr garnix zu tun, die regelt den zugriff auf das kill-flag.
strenggenommen muss die da sein, da ohne die mutex nicht garantiert ist dass die änderung die thread 1 an der variable macht auch für thread 2 "sichtbar" wird.