TTCPServer и два потока

bool mythreadRunning;
bool youthreadRunning;
 
class TMyThread : public TThread
{
__published:     IDE-managed Components
private:     User declarations
protected:   User declarations
 
    void __fastcall Execute();
public:     // User declarations
    __fastcall TMyThread(bool suspended);
};
 
__fastcall TMyThread::TMyThread(bool suspended)
    : TThread(suspended)
{
}
 
class TYouThread : public TThread
{
__published:    // IDE-managed Components
private:    // User declarations
protected:  // User declarations
    void __fastcall Execute();
public:     // User declarations
    __fastcall TYouThread(bool suspended);
};
 
__fastcall TYouThread::TYouThread(bool suspended)
    : TThread(suspended)
{
}
 
void __fastcall TMyThread::Execute()
{
  Form1->Memo1->Lines->Add("Process has been running for this many seconds:");
  for (int I = 0; I <= 10; I++)
  {
    Form1->Memo1->Lines->Add("Low priority process " + IntToStr(I));
    Sleep(1000);
  }
  mythreadRunning = FALSE;
}
 
void __fastcall TYouThread::Execute()
{
  Form1->Memo3->Lines->Add("Second low priority process has been running for this many seconds:");
  for (int I = 0; I <= 10; I++)
  {
    Form1->Memo3->Lines->Add("Second low priority process " + IntToStr(I));
    Sleep(1000);
  }
  youthreadRunning = FALSE;
}
 
void __fastcall TForm1::Button1Click(TObject *Sender)
{
  TMyThread *SecondProcess; // TMyThread is a custom descendant of TThread.
  if (mythreadRunning == FALSE)
  {
    mythreadRunning = TRUE;
    SecondProcess = new TMyThread(True); // Creation suspended--the second process does not run yet.
    SecondProcess->FreeOnTerminate = True; // No need to clean up after termination
    SecondProcess->Priority = tpLower;  // Set the priority to lower than normal.
    SecondProcess->Resume(); // Now run the thread.
  }
  else
    MessageDlg("This thread is still running. You are going to hurt yourself!",
      mtInformation, TMsgDlgButtons() << mbOK, 0);
}
 
void __fastcall TForm1::Button2Click(TObject *Sender)
{
  Form1->Memo2->Lines->Add("Do some work in the main process for 10 seconds:");
  for (int I = 0; I <= 10; I++)
  {
    Form1->Memo2->Lines->Add("Main process " + IntToStr(I));
    Sleep(1000);
  }
}
 
void __fastcall TForm1::Button3Click(TObject *Sender)
{
  TYouThread *SecondProcess; // TMyThread is a custom descendant of TThread.
  if (youthreadRunning == FALSE)
  {
    youthreadRunning = TRUE;
    SecondProcess = new TYouThread(True); // Creation suspended--the second process does not run yet.
    SecondProcess->FreeOnTerminate = True; // No need to clean up after termination
    SecondProcess->Priority = tpLower;  // Set the priority to lower than normal.
    SecondProcess->Resume(); // Now run the thread.
  }
  else
    MessageDlg("This thread is still running. You are going to hurt yourself!",
      mtInformation, TMsgDlgButtons() << mbOK, 0);
}
 
__fastcall TForm1::TForm1(TComponent* Owner)
  : TForm(Owner)
{
  mythreadRunning = FALSE;
  youthreadRunning = FALSE;
}

__fastcall TEnumeratorThread::TEnumeratorThread(TMemo* Memo)
    : TThread(true)
{
    /* Initialize internal fields */
    m_Memo = Memo;
    m_CurrNbr = 0;
    m_Stop = 0;
}
 
void __fastcall TEnumeratorThread::Execute()
{
    /* Repeat the loop until the flag says otherwise. */
    while (!m_Stop)
    {
        /* Wait for 100 milliseconds. */
        Sleep(100);
 
        /*
        Run the AddNewNumberToMemo procedure on the main thread.
        This makes it safe to access GUI from this thread.
        */
        Synchronize(AddNewNumberToMemo);
    }
 
    m_Stop = 0;
}
 
void __fastcall TEnumeratorThread::GentleStop()
{
  /* Set the flag to 1. */
  InterlockedIncrement(&m_Stop);
 
  /* Wait for this thread to finish executing */
  this->WaitFor();
}
 
void __fastcall TEnumeratorThread::AddNewNumberToMemo()
{
  /* Increase the current number and add it to the memo. */
  m_CurrNbr++;
  m_Memo->Lines->Add(IntToStr(m_CurrNbr));
}

//---------------------------------------------------------------------------
 
#include <vcl.h>
#pragma hdrstop
 
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
TTcpServer *TcpServer1;
TThread *hMyThread;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
        Form1->Memo1->Lines->Add( "Start, thread = " + (AnsiString)GetCurrentThreadId() );
 
        TcpServer1 = new TTcpServer(this);
        hMyThread = new TMyThreadClass(false);
}
//---------------------------------------------------------------------------
 
//---------------------------------------------------------------------------
 
//---------------------------------------------------------------------------
__fastcall TMyThreadClass::TMyThreadClass(bool suspended)
    : TThread(suspended)
{
        TcpServer1->BlockMode = bmThreadBlocking;
    TcpServer1->OnAccept = TcpServer1Accept;
    TcpServer1->OnCreateHandle = TcpServer1CreateHandle;
        TcpServer1->LocalPort = 6666;
    TcpServer1->Active = true;
}
//---------------------------------------------------------------------------
 
void __fastcall TMyThreadClass::Execute()
{
        // do something
}
 
void __fastcall TMyThreadClass::TcpServer1CreateHandle(TObject *Sender)
{
    TDateTime now = TDateTime::CurrentDateTime();
    Form1->Memo1->Lines->Add(DateTimeToStr(now) + " Server started. Thread = " + (AnsiString)GetCurrentThreadId());
}
 
void __fastcall TMyThreadClass::TcpServer1Accept(TObject *Sender, TCustomIpClient *ClientSocket)
{
        Form1->Memo1->Lines->Add( "Answer from client, thread = " + (AnsiString)GetCurrentThreadId() );
}

//---------------------------------------------------------------------------
 
#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <Sockets.hpp>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:    // IDE-managed Components
        TMemo *Memo1;
private:    // User declarations
public:     // User declarations
        __fastcall TForm1(TComponent* Owner);
};
 
class TMyThreadClass : public TThread
{
__published:    // IDE-managed Components
private:    // User declarations
protected:  // User declarations
    void __fastcall Execute();
        void __fastcall TcpServer1CreateHandle(TObject *Sender);
        void __fastcall TcpServer1Accept(TObject *Sender, TCustomIpClient *ClientSocket);
public:     // User declarations
    __fastcall TMyThreadClass(bool suspended);
 
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif