🚀 go-pugleaf

I have a multi-threaded application where each thread uses TClientSocket to 
communicate to a device on the network.  I start a new thread for each 
device that I need to talk to.  My main form starts each of these threads, 
and when a timer on the main form reaches 0, a flag is set in each thread to 
tell the thead that it is time to talk to it's device.  The next time the 
thread checks it's status, the thread calls new TClientSocket to allocate a 
new socket connection to use for the communication, retrieves the data, then 
deletes it's instance of TClientSocket.  Everything seems to work fine on my 
computer.  When I tried it on a client's computer, I began getting AVs when 
the thread was calling new TClientSocket.  I was creating my instances of 
TClientSocket as follows:

TClientSocket *sock = new TClientSocket(MainForm);

where MainForm is the address of my form with the timer and the form that 
creates the threads.

My theory as to why I would get AVs is that maybe all three threads are 
calling new TClientSocket(MainForm) almost simultaneously and basically, 
some method and/or property from my MainForm is being accessed by all three 
threads to add the TClientSocket component to the ComponentList array and 
increment the ComponentCount for the MainForm.  I changed the socket 
instantiation to new TClientSocket(NULL) and the problem has gone away. 
This seems to agree with my theory, but it's just a theory.  The biggest 
hole in my theory that I can see is that it doesn't really explain why it 
would work on my PC and not my clients.  We are both running XPSP2 on P4s. 
It still could be a timing issue, but I would like to prove this theory 
somehow.  Also, the only advantage that I can see to having MainForm being 
the owner of the TClientSocket is that if something unexpected occurs and 
the TClientSocket doesn't get deleted somehow, the MainForm will free up the 
memory when the form gets destroyed.  This advantage is greatly decreased by 
the fact that the form is never destroyed until the program exits, in which 
case Windows is going to free up the memory anyway.

Any thoughts, opinions, or additional theories (or even proofs with examples 
:P) on this would be greatly appreciated.

Regards,

Mark Atkin