You should use Lock() and Unlock() methods of TIdThreadSafe class. For example in TCPServer.OnExecute() call aNewIndyClass's methods like this:
aNewIndyClass := MyNewIndyClass.Create;
aNewIndyClass.Lock; // This will enter TIdThreadSafe internal's Critical Section object
try
with aNewIndyClass do // The code between try/finally will be "atomic"
begin // i.e. no other thread will be able to do anything with your object
...
FLocal.CallFuntionA;
FLocal.CallFuntionB;
...
end;
finally // The use of TRY/FINALLY is MANDATORY when working with critical sections!
aNewIndyClass.Unlock; // This will leave the CS
end;
Also it's better to use properties (i.e. getter/setter) for accessing private or protected members of your MyNewIndyClass class.
By the way if you are using Delphi 2009 and newer you can get advantage of Generics. A short example implementation of a generic thread safe class may be:
tThreadSafeObject<T: class> = class
private
fObject: T;
fCriticalSection: tCriticalSection;
public
constructor Create(cpObject: T); // We expect previously created object here. We own it!
// TODO: Implement ownership option?
destructor Destroy;
function Lock: T;
procedure Unlock;
end;
{ tThreadSafe<T> }
constructor tThreadSafeObject<T>.Create(cpObject: T);
begin
inherited Create;
fObject := cpObject;
fCriticalSection := TCriticalSection.Create;
end;
destructor tThreadSafeObject<T>.Destroy;
begin
FreeAndNil(fObject); // In this sample implementation fObject is owned so we free it
FreeAndNil(fCriticalSection);
inherited Destroy;
end;
function tThreadSafeObject<T>.Lock: T;
begin
fCriticalSection.Enter;
result := fObject;
end;
procedure tThreadSafeObject<T>.Unlock;
begin
fCriticalSection.Leave;
end;
Usage:
procedure foo;
var
tsObj: tThreadSafeObject<tMyClass>;
begin
tsObj := tThreadSafeObject<tMyClass>.Create(tMyClass.Create);
try // In real World tsObj would be variable, accessed by different threads
with tsObj.Lock do
try
// Do some atomic stuff here
finally
tsObj.Unlock;
end;
finally
freeAndNil(tsObj);
end
end;