Für boost-Asio Netzwerkprogrammierung was ist der beste Ansatz, um die Antwort für die Verarbeitung?

Question

Im neuen Programmierung zu vernetzen und insbesondere auf Asynchron-Prozesse. Starten Sie auch neu mit dem Boost-lib

Im eine Klasse Implementierung eines imap-Server zuzugreifen. Ich kann das Senden und Empfangen von Befehle und die Reaktion im allgemeinen

Die Antwort wird in einem dequeue innerhalb der Klasse der Warteschlange. Ich habe einfach die Antwortleitungen in der Warteschlange zur weiteren Verarbeitung.

Was ist jetzt der beste Weg, um die Warteschlange Antwort zu verarbeiten?

1. Ein extra Thread zu überprüfen (Zeitbasis) in die Warteschlange für neue Einträge?
2. Jedes Mal, wenn eine neue Einträge in die Warteschlange geschoben wird einige Rückruf machen?
   Wie kann ich diesen Rückruf implementieren und integrieren?

Vielleicht hat jemand hat ein kurzes Beispiel.

Danke

Answer 1

  

Jedes Mal, wenn ein neuen Einträge in die Warteschlange geschoben werden einigen Rückruf machen?   Wie kann ich diesen Rückruf implementieren und integrieren?

Ich nehme an, Sie mit einzelnen Thread synchrone Verbindung arbeiten.

Sie etwas wie folgt aus:

class worker {

    deque<message> messages;
    bool is_writing_;

    push_message(message msg) {
        messages.push_back(msg);
        notify();
    }

    void notify()
    {
        if(!is_writing_) {
            is_writing_=true;
            init();
        }
    } 

    void init()
    {
        if(messages.empty()) { is_writing_=false; return; }
        messamge msg=messages.pop();
        convert_to_vector(v);
        async_write(socket,buffer(v),
            boost::bind(&worker::complete,this,placehoders::error));
    }
    void complete(error_code const &e)
    {
        if(!e) {
            init();
        }
        else { cleanup(); }
    }

};

Hinweis !!!

Dies ist Single Thread-Implementierung. Wenn Sie von anderen Thread mitteilen möchten, sollten Sie

: nicht some_worker->push_message(msg) anrufen, sollten Sie iosrvice verwenden

service.post(boost::bind(&worker::push_message,some_worker,msg));

Und push_message würde aus dem gleichen Thread aufgerufen werden, die ioservice ausgeführt wird.

Answer 2

Eine Möglichkeit, die Warteschlange Prozessor zu implementieren, ist ein Signalisierungs Semaphore zu verwenden.

Zum Beispiel Pthread Konditionsart ( Beschreibung ) wenn Sie auf einer POSIX-kompatibelen Plattform.

könnten Sie haben eine Anzahl von N „queue-Verarbeitungs-Threads“ im Hintergrund warten.

1. Jedes Mal, wenn etwas in der Warteschlange geschoben Ihre Semaphore sendet sie Signal ist.

   • Das Signal wird durch Schlafen "queue-processing" Threads empfangen, die die Verarbeitung der Warteschlange gestartet werden, weil sie wissen, dass sie Daten.

   • Wenn der Thread beendet es die Verarbeitung von Daten, Warteschlangengröße überprüfen, um zu sehen, ob es etwas anderes greifen soll, wenn nicht, dann für ein Signal zu warten, gehen Sie zurück.