Is there anyway to know the status of a TEvent? - delphi

Question

I have several threads, each with its own TEvent:
TWorkerThread = class(TThread)
private
FSignal: TEvent;
public
constructor Create;
destructor Destroy; override;
procedure Execute; override;
end;
procedure TWorkerThread.Execute;
var ID: integer;
begin
while not Terminated do begin
Tmonitor.Enter(MainQueue);
try
if (MainQueue.Count > 0) then ID := MainQueue.dequeue
else ID := 0;
finally
Tmonitor.exit(MainQueue);
end;
if (ID <> 0) then ProcessID(ID)
else fSignal.WaitFor(INFINITE);
end;
end;
Now, in the main thread I would like to retrieve the list of threads that are waiting for the signal, so those who are doing fSignal.WaitFor(INFINITE);
Actually I do like this in the code:
procedure AddIDToTheQueue(const id: integer);
begin
Tmonitor.Enter(MainQueue);
try
MainQueue.Enqueue(id);
//signal all background thread !!! this a don't like i prefer to signal only one thread who are waiting instead of signaling all the threads !!!
for I := Low(workerThreads) to High(workerThreads) do
workerThreads[i].Signal.SetEvent;
finally
Tmonitor.Exit(MainQueue);
end;
end;
but it's not efficient as I signal all threads instead of signalling only the first one that is waiting for the signal. How can I do this?

Answer 1

To directly answer your question, you can always check if an event is signalled using :
if FSignal.WaitFor(0) = wrSignaled then begin
// event is signaled
end;
If you need to handle all cases, of course :
case FSignal.WaitFor(0) of
wrSignaled:;
wrTimeout:;
wrAbandoned:;
wrError:;
wrIOCompletion:;
end;
However - this is an ideal situation to leverage the built-in threadpool by simply using tasks.
For example, all of your code can be eliminated and reduced to this :
procedure AddIDToTheQueue(id: integer);
var
LTask : ITask;
begin
LTask := TTask.Create(procedure begin ProcessID(id); end);
LTask.Start;
end;
There is no sense in passing an integer as const. Whether you pass the value or a pointer, it's the same size. If you're not modifying it, it makes no difference.

Answer 2

I would not use events in this situation.
I would use yield.
Then Execute becomes
procedure TWorkerThread.Execute;
var
ID : integer;
begin
while not Terminated do begin
Tmonitor.Enter(MainQueue);
try
if (MainQueue.Count > 0) then ID := MainQueue.dequeue
else ID := 0;
finally
Tmonitor.exit(MainQueue);
end;
if (ID <> 0) then ProcessID(ID)
else Yield;
end;
end;
and AddIDToTheQueue becomes
procedure AddIDToTheQueue(const id: integer);
begin
Tmonitor.Enter(MainQueue);
try
MainQueue.Enqueue(id);
finally
Tmonitor.Exit(MainQueue);
end;
end;
You are not attempting to tell your threads that a new ID is available. You are letting the first available thread handle it automatically.

Answer 3

Calling TEvent.WaitFor(0) it's a bit slower... You cand make a new beautiful Event that uses Critical Section to fast check for singaled state. In this example, I also added a value to the event which can help you send a command with that signal too.
TSafeCardinalEvent = class
private
CardinalValue: Cardinal;
CS: TRTLCriticalSection;
hEvent: THandle;
function GetEventValue: Cardinal;
procedure SetEventValue(AValue: Cardinal);
public
constructor Create; virtual;
destructor Destroy; override;
function Signaled: Boolean; overload; {$IFDEF RELEASE} inline; {$ENDIF}
function Signaled(out Code: Cardinal): Boolean; overload;
property Value: Cardinal read GetEventValue write SetEventValue;
property EventHandle: THandle read hEvent;
end;
constructor TSafeCardinalEvent.Create;
begin
inherited Create;
CardinalValue:= 0;
InitializeCriticalSection(CS);
hEvent:= CreateEvent(nil, True, False, nil);
end;
destructor TSafeCardinalEvent.Destroy;
begin
CloseHandle(hEvent);
DeleteCriticalSection(CS);
inherited Destroy;
end;
function TSafeCardinalEvent.Signaled: Boolean;
begin
EnterCriticalSection(CS);
Result:= CardinalValue > 0;
LeaveCriticalSection(CS);
end;
function TSafeCardinalEvent.Signaled(out Code: Cardinal): Boolean;
begin
EnterCriticalSection(CS);
Code:= CardinalValue;
Result:= CardinalValue > 0;
LeaveCriticalSection(CS);
end;
function TSafeCardinalEvent.GetEventValue: Cardinal;
begin
EnterCriticalSection(CS);
Result:= CardinalValue;
LeaveCriticalSection(CS);
end;
procedure TSafeCardinalEvent.SetEventValue(AValue: Cardinal);
begin
EnterCriticalSection(CS);
CardinalValue:= AValue;
if CardinalValue = 0
then ResetEvent(hEvent)
else SetEvent(hEvent);
LeaveCriticalSection(CS);
end;