linux c++ periodische timer callback

Ich versuche zu schreiben ein einfaches Programm, das in seiner main-loop ruft verschiedene Funktionen auf der Grundlage der Benutzereingabe (hier kein problem) und auch einige Aktionen auf seine eigene - das sind Zeit basiert.
Da ich vermeiden möchte mögliche Daten-access-Probleme (ich bin nicht gut im multithreading) ich habe versucht, um Rückrufe zu gewährleisten, verschiedene autonome Teile des Programms aufgerufen werden würde jeder so-und-so Millisekunden.

Von dem, was ich gefunden habe, boost::asio-sieht aus wie der Weg zu gehen - allerdings weiß ich nicht, was ist der richtige Ansatz hier. Ich habe einen einfachen code, der funktioniert:

#include <iostream>

#include <boost/asio.hpp>//scheduling
#include <boost/date_time/posix_time/posix_time.hpp>
using namespace std;

void clb(const boost::system::error_code&){
    // eye.procFrame(&img, true);
    cout << "callback ok" << endl;
}
int main() {
    bool run = true;
    int i =0;

    while(run){
        boost::asio::io_service io;
        boost::asio::deadline_timer t(io, boost::posix_time::seconds(2));
        t.async_wait(clb);
        io.run();
        if(++i>10) run = false;
    }
    cout << "done, i=" << i;
    return 0;
}

Mein wichtigstes Anliegen ist es, die Erklärungen - wenn ich verschieben Sie Sie außerhalb der while-Schleife, wird der Rückruf erfolgt nur einmal. Gibt es eine Möglichkeit zu schreiben, Rückrufe zu ähneln timer-interrupts vom mikrocontroller?

Schlafen ist keine Lösung - es würde machen das Programm nicht mehr reagiert und würde nicht garantieren, dass Teile des Programms sind aktualisiert, nach Ihrem Zeitplan (z.B. GUI aktualisieren jeden 25ms, aber das aufnehmen sollte auftreten, nur 10 mal in der Sekunde[100ms Zeit) als eine schwere operation unter eine Menge von Ressourcen]

Vielleicht gibt es einen völlig anderen Ansatz, der besser wäre? Ich dachte, mehr threads, aber ich fürchte, wenn ich versuchen und Faden jedes Stück Programm werde ich am Ende mit einer Schüssel spaghetti, ich würde nie in der Lage sein zu verwalten, auf lange Sicht.

Deine überlegungen sind richtig, Sie müssen diese von einem separaten thread aus. Ich verstehe nicht, warum das dazu führen sollte, dass spaghetti-code.
Da ich mehrere Teile, die aufgerufen werden müssen in verschiedenen Intervallen, die ich brauchen würde, einen thread für jede Methode. Dann würde ich brauchen, um sicherzustellen, dass Sie nicht in eine race-condition oder einem deadlock. EDIT: Außerdem, ist das nicht ein performance-Problem wenn ich spawn sagen wir 5-10 threads?
Sie müssen nur ein thread pro timer, und könnte umhüllter in t ist eine eigene Klasse. Ich fürchte, du hast mich falsch.
Also der thread laufen würde, den Teil des Codes habe ich in die while-Schleife? Dann wird jeder - wenn timer verantwortlich für den besonderen Teil des code abläuft - nennen würde, der Rückruf? Ich werde es wohl neu schreiben müssen Teil der Schnittstelle (ich habe ncurses)
'So, der thread laufen würde, den Teil des Codes habe ich in die while-Schleife?' Mehr oder weniger, denke ich. Man könnte sogar ein einfaches sleep() im timer-thread-Funktion.

InformationsquelleAutor user3002166 | 2014-03-20

boost-asio c++linux timer

1

Wenn Sie möchten, dass Ihre timer, um das Feuer immer wieder, Sie können einfach anrufen deadline_timer::expires_from_now und deadline_timer::async_wait in Ihrem timer-callback. Dadurch wird der timer re-planen Sie selbst jedes mal, wenn es feuert.

Den Timern verbunden mit einem io_service - Objekt, das ausgeführt werden soll, die auf einem oder mehreren threads. Sie können eine beliebige Anzahl von Timer im Zusammenhang mit einem einzigen io_service. Wenn Sie möchten, dass Ihre Timer zu Seriell ausgeführt werden und sich keine sorgen über die Parallelität Probleme, nur noch einen einzigen thread laufen Ihre io_service.

In diesem Beispiel habe ich einen thread laufen, ein io_service mit zwei Timer.
```
#include <iostream>
#include <boost/asio.hpp>
#include <boost/chrono.hpp>

boost::asio::io_service io;
boost::asio::deadline_timer timerA(io);
boost::asio::deadline_timer timerB(io);
boost::chrono::steady_clock::time_point appStart;

void onTimerA(const boost::system::error_code& error)
{
    assert(!error);
    std::cout << "A fired at " << 
        boost::chrono::duration_cast<boost::chrono::milliseconds>
        (boost::chrono::steady_clock::now() - appStart).count() 
        << std::endl;

    timerA.expires_from_now(boost::posix_time::seconds(1));
    timerA.async_wait(onTimerA);
}

void onTimerB(const boost::system::error_code& error)
{
    assert(!error);
    std::cout << "B fired at " << 
        boost::chrono::duration_cast<boost::chrono::milliseconds>
        (boost::chrono::steady_clock::now() - appStart).count() 
        << std::endl;

    timerB.expires_from_now(boost::posix_time::seconds(2));
    timerB.async_wait(onTimerB);
}

int main()
{
     //Prevents io.run() from returning.
    boost::asio::io_service::work work(io);

    appStart = boost::chrono::steady_clock::now();

    timerA.expires_from_now(boost::posix_time::seconds(1));
    timerA.async_wait(onTimerA);

    timerB.expires_from_now(boost::posix_time::seconds(2));
    timerB.async_wait(onTimerB);

    io.run();
}
```
Jedoch der Nachteil an, dass sich ein Faden ist, dass, wenn eine der timer-callbacks dauert eine lange Zeit zum ausführen, es wird blockieren andere Zeitgeber, sollte gefeuert haben, bis es abgeschlossen ist. Wenn Sie wissen, dass Ihre timer-callbacks wird nicht lange dauern, ein thread wird in Ordnung sein, obwohl.

Zum Beispiel, wenn Sie timer A auf 25 ms-Intervalle und timer B auf 50 ms-Intervallen, die beiden Timer werden manchmal geplant werden, um das Feuer in der gleichen Zeit. Einer von Ihnen wird zuerst ausgeführt, die anderen warten darauf, dass die Ausführung abgeschlossen ist, und führen Sie dann selbst.

Wenn Sie erwarten, dass Ihre timer-callbacks, um eine lange Zeit dauern und Sie nicht haben, können Sie Ihre Timer-das warten auf andere Hasen " Rückrufe zu beenden, müssen Sie zusätzliche threads laufen Ihre io_service.

Also, die operation verzögert werden, und nicht "vergessen"? In einem solchen Fall wird es schaffen, die wachsenden Verzögerungen, wenn Operationen machen sich gegenseitig warten?

InformationsquelleAutor Collin Dauphinee

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.