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*

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();
}

Danke 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?

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)

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*

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.