Sieht jemand was ich hier falsch mache? io_service::run() ist ja angeblich von mehreren Threads aufrufbar. Ich möchte dass jeder Thread eine bestimmte Anzahl von Warteoperationen hintereinander ausführt (zu Testzwecken), später möchte ich diese durch schreib- und Leseoperationen ersetzen. Das schreiben und Lesen auf ein Socket soll dann parallel ablaufen. Aber offenbar gibts hier ein Problem dass jeder Thread run() nur einmal ausführen kann.

#include <iostream>
#include <boost/thread.hpp>
#include <boost/asio.hpp>

boost::mutex m;

class Thread
{
    boost::asio::io_service* m_io;
    boost::asio::strand m_strand;
    char* m_name;
    int m_n;
    int m_t;

    public:

        Thread(char* name, int n, int t, boost::asio::io_service& io): m_io(&io), m_strand(io),
            m_name(name), m_n(n), m_t(t)
        {
        }

        void Handler(const boost::system::error_code& ec)
        {
            boost::lock_guard<boost::mutex> lock(::m);

            if(ec)
            {
                std::cout << ec.message() << '\n';
            }
            else
            {
                std::cout << m_name << '\n';
            }
        }

        void operator ()()
        {
            boost::asio::deadline_timer t(*m_io);

            for(int i = 0; i < m_n; ++i)
            {
                t.expires_from_now(boost::posix_time::milliseconds(m_t));
                t.async_wait(m_strand.wrap(boost::bind(&Thread::Handler, this, _1)));
                m_io->run();
            }
        }
};

int main()
{
    try
    {
        boost::asio::io_service io;

        boost::thread t1(Thread("T1", 10, 1000, io));
        boost::thread t2(Thread("T2", 5, 2000, io));
        boost::thread t3(Thread("T3", 3, 3000, io));

        t1.join();
        t2.join();
        t3.join();
    }
    catch(std::exception &e)
    {
        std::cout << e.what();
    }

    return 0;
}

io_service::run() ist ja angeblich von mehreren Threads aufrufbar.

Wie kommst du auf diese Idee? Das wäre mir ganz neu.

Grüssli

Stefan schrieb:

io_service::run() ist ja angeblich von mehreren Threads aufrufbar.

Wie kommst du auf diese Idee? Das wäre mir ganz neu.

Grüssli

Aus der Doku:

Multiple threads may call io_service::run() to set up a pool of threads from which completion handlers may be invoked. This approach may also be used with io_service::post() to use a means to perform any computational tasks across a thread pool.

http://www.boost.org/doc/libs/1_42_0/doc/html/boost_asio/overview/core/threads.html

Stefan schrieb:

io_service::run() ist ja angeblich von mehreren Threads aufrufbar.

Wie kommst du auf diese Idee? Das wäre mir ganz neu.

Grüssli

Das ist sogar die Idee... der Fall, dass run(..) nur von einem Thread aus aufgerufen wird ist eher ein spezial Fall.

Die Idee ist, dass alle Threads, die run(..) aufrufen zum Thread Pool gehören (implizit). Handler werden dann auf einem dieser Threads aufgerufen.

Mit io_service::strand können die Handler aufrufe serialisiert werden.

Simon

Was ich letztendlich erreichen will ist simultanes schreiben und lesen auf einem Socket, ohne dass das eine das andere blockiert. Also, ein Thread sendet Daten, der andere empfängt. Falls jemand weiss wie man das mit boost::asio realisieren kann, wäre ich dankbar für einen Tipp.

Du benutzt einfach async_write(..) und async_read(..) und fertig.

Und wo liegt hier jetzt das Problem oder ist das nun beseitigt? Die Problembeschreibung ist ja nicht wirklich berauschend

Grüssli

Ich wollte eben zuerst paralleles Warten ausprobieren (anstatt lesen und Schreiben), weil mir das Protokoll noch fehlt.

Dann sag mir was die Fehlermeldungen verursacht.

Welche Fehlermeldung?

Zweitens:

Stefan schrieb:

Aber offenbar gibts hier ein Problem dass jeder Thread run() nur einmal ausführen kann.

Da ist auch so. Jeder Thread in dem io_service::run ausgeführt wird stellt eine eigenständige Queue zur asynchronen Verarbeitung dar. Damit ist der Thread dann vollzeitbeschäftigt.

Dein Handler kann allerdings durch den Stand (und den Mutex) nur jeweils in einem Thread gleichzeitig ausgeführt werden.

PS: Dein deadline_timer lebt nicht lange genug:

void operator ()()
{
    //hier legst Du ihn als auto-Variable an.
    boost::asio::deadline_timer t(*m_io);

    for(int i = 0; i < m_n; ++i)
    {
        t.expires_from_now(boost::posix_time::milliseconds(m_t));

        t.async_wait(m_strand.wrap(boost::bind(&Thread::Handler, this, _1)));
        m_io->run();
    }
    //hier, also beim Verlassen der Funktion stirbt Dein Timer
    //(während er auf den Timeout wartet)
    //der Handler wird dadurch abgeschossen,
    //so als wenn man cancel() aufruft. Daher die "Fehlermeldung".
}

[...]Es ist doch so dass alle Handler, die in den gleichen Strand gewrapt wurden, in dem Thread ausgeführt werden, in dem das Strand-Objekt erzeugt wurde. Oder habe ich das falsch verstanden?

Das strand -Objekt wurde ja nicht in einem Thread erzeugt, sondern er benutzt ein io_service -Objekt. Wenn die run -Methode des io_service -Objektes in mehreren Threads ausgeführt wird, dann können Handler, die in dem io_service hängen normalerweise parallel ausgeführt werden. Von allen Handlern, die in einen strand gepackt werden, kann jeweils nur noch einer zur Zeit aktiv sein. Alle anderen müssen warten, bis der gerade aktive Handler fertig ist.

Beispiel:
Du hast einen TCP-Server, der asynchron Verbindungen annehmen kann ( async_accept ). Jede erfolgreich angenommene Verbindung soll zur weiteren Verarbeitung in einen Container gelegt werden. Damit Dein Server besser skaliert, hast Du nun die run -Methode des io_service -Objektes auf dem async_accept arbeitet in mehreren Threads gestartet. Dadurch können nun mehrere connect -Anfragen zur gleichen Zeit behandelt werden. Das heisst dann auch, dass mehrere accept -Handler versuchen können, die Verbindungen in den Container einzutragen. Wenn der nicht threadsafe ist, dann knallt es. Wenn Du den accept -Handler nun in einen strand wickelst, wird kann nur jeweils ein Handler zur Zeit ausgeführt werden. Es geht bei einem strand also darum, dass von verschiedenen Threads, welche in den durch den strand geschützten Bereich eintreten wollen nur jeweils einer aktiv sein darf.