Implementare la registrazione protetta da thread

Question

Il mio compito è quello di creare una classe che raccolga l'attività dell'utente attorno a diverse applicazioni.

Diciamo che ho una classe TLogging e un oggetto globale chiamato Logging.

L'attività dell'utente (schermata aperta, ecc.) Deve essere raccolta in memoria (può essere inserita in una lista (stringa) di TLogging) e salvata nel file di registro dopo un intervallo di tempo (ogni 10 minuti) o quando l'applicazione è chiuso.

Il più importante è che la registrazione deve essere in "modalità silenziosa", non deve influire in alcun modo sul flusso di lavoro dell'utente: nessuna schermata sospesa, nessuna eccezione.

Per favore dammi la direzione per questo compito.

Answer 1

Questa è una domanda molto ampia che tocca diverse aree. Alcuni suggerimenti:

• Almeno considerare un quadro di registrazione stabilito per questo. Le versioni Delphi più recenti sono disponibili con CodeSite. SmartInspect è un'altra alternativa.

• primitive di sincronizzazione Usa per rendere la vostra classe thread-safe: TCriticalSection, TMREWSync

• Accertarsi di aver capito i problemi coinvolti nel multithreading e la sincronizzazione prima di tentare di scrivere un quadro di registrazione thread-safe. Un buon inizio è la guida di Martin Harvey Multithreading - The Delphi Way.

• Utilizzare un thread in background che svuota il contenuto del registro sul disco a intervalli regolari o se è stato memorizzato un numero sufficiente di dati.

• Chiedi domande più specifiche qui su SO se riscontri problemi specifici.

Answer 2

Utilizzando OmniThreadLibrary e assumendo che l'oggetto di registrazione è un singleton, questo è veramente semplice. Vorrei anche limitare il numero massimo di messaggi in attesa di essere scritti in modo che la coda interna non possa usare troppa memoria.

const 
    CMaxMsgCount = 1000; 
    CMaxLogTimeout_ms = 10{min}*60{sec/min}*1000{ms/sec}; 

type 
    TLogging = class 
    strict private 
    FLogMsgCount: IOmniResourceCount; 
    FLogQueue: IOmniBlockingCollection; 
    FWriter: IOmniTaskControl; 
    strict protected 
    procedure Logger(const task: IOmniTask); 
    public 
    constructor Create; 
    destructor Destroy; 
    procedure Log(const msg: string); 
    end; 

var 
    Logging: TLogging; 

constructor TLogging.Create; 
begin 
    FLogMsgCount := CreateResourceCount(CMaxMsgCount); 
    FLogQueue := TOmniBlockingCollection.Create; 
    FWriter := CreateTask(Logger, 'Logger').Run; 
end; 

destructor TLogging.Destroy; 
begin 
    FWriter.Terminate; 
end; 

procedure TLogging.Log(const msg: string); 
begin 
    FLogQueue.Add(msg); 
    FLogMsgCount.Allocate; 
end; 

procedure TLogging.Logger(const task: IOmniTask); 

    procedure Flush; 
    var 
    logData: TOmniValue; 
    begin 
    // open file, possibly with retry 
    while FLogQueue.TryTake(logData) do begin 
     FLogMsgCount.Release; 
     // write logData.AsString 
    end; 
    // close file 
    end; 

begin 
    while DSiWaitForTwoObjects(task.TerminateEvent, FLogMsgCount.Handle, false, CMaxLogTimeout_ms) <> WAIT_OBJECT_0 do 
    Flush; 
    Flush; 
end; 

(Esonero di responsabilità: "Compila sulla mia macchina", altrimenti non testati.)