Gibt es ein Designmuster, das nicht der Produzent ist, um dieses Muster zu beschreiben?

Question

In meiner Anwendung in C++ verwende ich Pthreads. Ich habe einen Hauptthread, der Arbeit austeilt, um einen anderen Thread von Datenträger zu lesen, und einen dritten Thread, um auf Datenträger zu schreiben. Dies ermöglicht es dem Haupt-Thread, in Echtzeit zu arbeiten und keinen Schluckauf aufgrund von Disk-Io durch den Lese-Thread zu erhalten, der vor dem Haupt-Threads-Verbrauch steht und der Schreib-Thread mit der Haupt-Thread-Produktion Schritt hält. Mit anderen Worten, der Lese-Thread erzeugt Daten zur Verarbeitung durch den Haupt-Thread und der Schreib-Thread verbraucht Daten, die von dem Haupt-Thread erzeugt werden.

In meiner Anwendung habe ich Ressourcen zwischen dem Haupt-Thread und dem Lese-Thread freigegeben, und ich habe einen anderen Satz von freigegebenen Ressourcen zwischen dem Haupt-Thread und dem Schreib-Thread. In Zeiten, in denen keine Synchronisation zwischen Threads erforderlich ist, greift der Haupt-Thread frei auf die freigegebenen Ressourcen der Lese- und Schreib-Threads zu. Wenn es dann Arbeit bereitstellen will, die gelesen oder geschrieben werden soll, richtet es die geteilten Ressourcen ein, um die erforderliche Arbeit anzuzeigen, und gibt dann eine Bedingungsvariable aus, um den Lese- oder Schreib-Thread (falls zutreffend) darüber zu benachrichtigen, dass es die Anforderung von der gemeinsamer Bereich. Sie blockiert sich dann selbst, bis der angeforderte Thread das Sammeln der Anforderung abgeschlossen hat, und gibt eine separate Zustandsvariable frei, auf die sie wartet. Auf diese Weise greift der Haupt-Thread in seinem normalen Zustand auf die gemeinsam genutzte Ressource zu und blockiert sich selbst, indem er auf die Bedingung während Perioden wartet, wenn sein Lese- oder Schreib-Thread Zugriff benötigt, wohingegen die Lese- und Schreib-Threads entgegengesetzt sind, da sie in ihrem normalen Zustand sind Sie greifen nicht auf die freigegebene Ressource zu, sondern nur während Synchronisierungsperioden, wenn der Hauptthread signalisiert hat und darauf wartet, dass sie ihren Zugriff abschließen.

ist hier einige sehr grobe Pseudo-Code (nicht über genau hier fließen Sorge, dies ist nur eine grobe Vorstellung von der Funktionsweise Code ist):

MainThread: 
    do { 
    While (no pending requests) { 
     manipulate shared resources; 
    } 
    if (need write && ready for read requests) { 
     setup write request in shared resources; 
     Release condition startWrite variable; 
     Wait on condition endWrite variable; 
    } 
    if (need read && ready for read requests) { 
     setup read request in shared resources; 
     Release condition startRead variable; 
     Wait on condition endRead variable; 
    } 
    } 
ReadThread: 
    do { 
    Notify I am ready for read requests; 
    Wait on condition startRead; 
    copy request out of shared resources; 
    update shared resources to account for reads completed; 
    Release condition EndRead; 
    Perform Read from disk; 
    } 
WriteThread: 
    do { 
    Notify I am ready for write requests; 
    Wait on condition startWrite; 
    copy request out of shared resources; 
    update shared resources to account for writes completed; 
    Release condition EndWrite; 
    Perform write to disk; 
    } 

Meine Frage, ob dies nur ein normaler Produzent angesehen wird Verbraucher-Design-Muster oder ob es ein spezifischeres allgemein akzeptiertes Designmuster gibt, das beschreiben würde, was ich geschaffen habe?

Answer 1

Sie erhalten eine Hintergrundaktivität für die Eingabe und Ausgabe unabhängig von der Mainline-Verarbeitung. Lesevorgänge können im Voraus geplant werden, so dass die Daten bei Bedarf bereits vorhanden sind, und Schreibvorgänge können als Hintergrundaktivität ausgeführt werden, sodass die Hauptlinie nicht blockiert werden muss, wenn Daten in den Speicher geschrieben werden.

Dieses "Entwurfsmuster" hat einen Namen, der als "asynchronous IO" bekannt ist.

Answer 2

Haben Sie sich die read/write lock pattern angesehen? Das Scheduler-Muster wäre eine andere Idee, obwohl ich nicht sicher bin, wie gut das in Ihrer gegebenen Situation funktionieren würde.

Answer 3

Sie könnten dies als eine Instanz des "Master/Worker" -Musters beschreiben. Der "Master" -Thread verteilt die Arbeit (Lese- oder Schreibanforderungen) an die "Worker" -Threads (den Lese-Thread und den Schreib-Thread).