Aktualisierung des Datenbank-Datensatzes nur nach 20 Sekunden Wartezeit, damit der maximale Datensatz empfangen werden kann

Question

Aktualisierung des Datenbank-Datensatzes erst nach 20 Sekunden Wartezeit, damit der maximale Datensatz empfangen werden kann.

Wenn ein Schülerdatensatz von einem Werkzeug (Ein Werkzeug, das der Datenbank neue Schülerdetails hinzufügt) hinzugefügt wird, wird ein Ereignis, dh RecordChangedEvent, gesendet, und dieses Werkzeug kann viele Datensätze gleichzeitig hinzufügen.

Hinweis: Wenn RecordChangedEvent empfangen ich einen Anruf tätigen müssen, um changed.list den neu hinzugekommenen Schüler Rekord

Let sagen erste Mal, dass ich hinzugefügt 200 Datensätze von Werkzeugen und Tools senden 200 RecordChangedEvent zu erhalten aber hier möchte ich nicht 200 Ereignisse erhalten, sondern ich werde um 20 Sekunden verzögert und ignoriere, was während dieser Verzögerung kommt.

nach der Rückkehr aus Verzögerung kommen muss ich auf changed.list nennen, die alle neu hinzugefügten Datensätze hinzufügen wird, die, wenn es darum ging, in 20 Sekunden Verzögerung war und sie alle in einem Rutsch hinzuzufügen.

Mein Problem ist, dass ich 200 RecordChangedEvent bekomme und es wird um 200 * 20 Sekunden verzögert (was schlecht ist). Ich möchte alle Ereignisse ignorieren, wenn es auf Verzögerung ist, und wenn es erhalten nach einer Verzögerung wieder nur die Update-Liste von changed.list

Unten ist mein Ansatz (ineffizient)

RecordChangedEvent(void) 
{ 
    static bool lock = false; 
    bool updateNewRecord = false; 

    // delaying for 20 sec when first event received so that max record can be received 
    if(!lock) 
    { 
     lock = true; 
     std::this_thread::sleep_for(std::chrono::seconds(20)); 
     updateNewRecord = true; 
    } 
    if(updateNewRecord) 
    { 
     // adding after 20 sec delay changed.list will have all the updated received records within 20 seconds     
     AddedRecord(changed.list);  
     lock = false; 
    } 
} 

Answer 1

Sie benötigen mehrere Threads aufrufen RecordChangedEvent. Wenn Sie nur einen Thread verwenden, wird dieser Thread für 20 Sekunden blockiert, bevor er zurückkehrt, das nächste Ereignis erhält und dann erneut RecordChangedEvent aufruft (wo er erneut 20 Sekunden lang wartet). Sie benötigen also mindestens einen weiteren Thread, um Ereignisse zu verarbeiten, während der erste Thread schläft.

Sobald Sie mehrere Threads haben, können Sie immer noch Probleme auftreten. Ihre lock Variable ist nicht threadsicher. Es besteht die entfernte Möglichkeit, dass zwei Threads gleichzeitig mit dem Schloss in das if gelangen können. Es gibt auch keine Garantie dafür, dass eine Änderung an lock in einem Thread in einem anderen sofort sichtbar ist. Sie sollten stattdessen ein Standardsperrobjekt verwenden.

Eine weitere Quelle der Probleme ist, dass die Nutzung von changed.list hier nicht synchronisiert ist, da man von ihm gerade lesen (entweder es zu kopieren AddRecord oder innerhalb AddRecord passieren, wenn Sie es in durch Verweis übergeben), während an anderer Stelle in Ihrem Programm Ein anderer Thread kann versuchen, der Liste ein neues Element hinzuzufügen.