Wie könnte ich ein Objekt serialisieren, ohne dass die Gefahr besteht, dass Daten beschädigt werden?

Question

Ich möchte eine Basisklasse wie diese serialise:

class ProcessData 
{ 
    public: 
    ProcessData(); 
    ProcessData(int processNumber, int threadStatus); 
    ~ProcessData(); 
    int getProcessNumber() const; 
    void setProcessNumber(int processNumber); 
    int getThreadStatus() const; 
    void setThreadStatus(int threadStatus); 
    private: 
    int _processNumber; 
    int _threadStatus; 
}; 

und schreiben Sie es auf eine Named Pipe. Ich benutze Named Pipe, weil ich meinen Child-Prozess brauche, um Daten an meinen Hauptprozess zu senden.

Mein Hauptprozess wird diese Named Pipe lesen und mein Objekt zurückbekommen.

Problem ist, dass viele Prozesse in die Named Pipe schreiben könnten, was zu Problemen führen kann. Um diese Klasse serialise Ich dachte, ich, so etwas zu können:

write(namePipeFileDesriptor, &processDataClass, sizeof(processDataClass))); 

Glauben Sie, dass könnte funktionieren, oder gibt es noch andere Alternativen, außer boost::serialization?

Answer 1

Solange Reader- und Writer-Prozesse auf demselben Computer ausgeführt werden, für dasselbe Ziel mit denselben Ausrichtungsregeln kompiliert werden und dass zu versendende Daten POD sind (oder als POD betrachtet werden können), können Sie Ihre Daten pipen Daten wie sie sind, wie Sie vorschlagen, und vermeiden Sie die Verwendung einer Serialisierungsbibliothek.

Nun geht es Ihrer Meinung nach um die Atomizität von Schreib-/Leseoperationen, egal welche Serialisierungstechnik Sie verwenden, wenn man bedenkt, dass mehrere Schreibprozesse in die Pipe schreiben können.

Angenommen, Ihr Betriebssystem ist POSIX-kompatibel, können Sie jede Schreiboperation als atomar betrachten (dh keine Verschachtelung von Daten), solange die Größe der gesendeten Daten die Pipe-Puffergröße nicht überschreitet.

Standard Zustände:

Schreibanforderungen von {PIPE_BUF} Bytes oder weniger werden nicht mit Daten aus anderen Prozessen zu tun schreibt auf dem gleichen Rohr verschachtelt werden. Bei Schreibvorgängen mit mehr als {PIPE_BUF} -Bytes können Daten an beliebigen Grenzen mit Schreibvorgängen durch andere Prozesse verschachtelt werden, unabhängig davon, ob das O_NONBLOCK-Flag der Dateistatusflags gesetzt ist oder nicht.

Der Wert PIPE_BUF ist vom Betriebssystem abhängig, sollte jedoch größer als 512 Byte sein. (Es ist 4096 Bytes für Linux-Betriebssysteme.) Also, für kleine Daten sollte es kein Problem geben.

Answer 2

Ich empfehle, google::protobuf Bibliothek für Serialisierung und Deserialisierung zu verwenden. Es ist effizient und schnell.

Für Ihren Fall haben Sie einfach eine Datei .proto

// File.proto 
message ProcessData 
{ 
    int32 _processNumber; 
    int32 _threadStatus; 
} 

Nachdem es mit protoc-Compiler erstellen, werden Sie "File.pb.h" und "File.pb.cpp" erhalten, die Sie Ihrem eigenen Projekt hinzufügen müssen. Das ist es. Jetzt können Sie die erforderlichen Daten einfach serialisieren und deserialisieren, indem Sie verschiedene Methoden in diesen Quelldateien verwenden.

Ein weiterer zusätzlicher Vorteil ist, dass das gleiche "File.proto" für andere Sprachen wie Go, Phython, Java, C#, ... verwendet werden kann. Weil die Nachricht auf sprachunabhängige Art und Weise serialisiert wird.