Thread synchronization and GUI

[mark_c]

Hello,
I'm struggling with an old educational project for the study of synchronization, I do not understand why in this case there is no collision!
In my opinion, it should be there when Thread1 writes to the StringGrid: am I wrong?

Thank you

Code: Select all

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"

class TMyThread1 : public TThread
{
protected:
	void __fastcall Execute();
public:
	__fastcall TMyThread1();
	void __fastcall MySincrSock1();
	String msg;
};

TMyThread1 *Thread1 = NULL;


//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
	ServerSocket1->Port = 5000;
	ServerSocket1->Active = true;
}
//---------------------------------------------------------------------------

__fastcall TMyThread1::TMyThread1()
: TThread(true)
{
}
//---------------------------------------------------------------------------

void __fastcall TMyThread1::MySincrSock1()
{
	try{
		for(int actconn = 0; actconn < Form1->ServerSocket1->Socket->ActiveConnections; actconn++)
		{
			Form1->ServerSocket1->Socket->Connections[actconn]->SendText(msg);
			Form1->Caption="1";
		}

	} catch(...) { }
}
//---------------------------------------------------------------------------

void __fastcall TMyThread1::Execute()
{
	while (!Terminated)
	{
		for(int i=0; i<10;i++)
		{
			msg.sprintf("Y27.5,1,192.168.1.%d,5694,25,25,127",i);
			Synchronize(&MySincrSock1);

                        Form1->StringGrid1->Cells[1][i]=msg;
			Sleep(100);
			Form1->StringGrid1->Cells[1][i]="";
		}
	}
}
//---------------------------------------------------------------------------

void __fastcall TForm1::FormDestroy(TObject *Sender)
{
	delete Thread1;

	ServerSocket1->Active = false;
        
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
	Thread1 = new TMyThread1();

	Button1->Enabled = false;
	Button2->Enabled = true;

	Caption = "Started.....";

	Thread1->Resume();        
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
	if (Thread1) Thread1->Terminate();

	Button1->Enabled = true;
	Button2->Enabled = false;

	Caption = "Stopped.....";        
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ServerSocket1ClientError(TObject *Sender,
      TCustomWinSocket *Socket, TErrorEvent ErrorEvent, int &ErrorCode)
{
	Socket->Close();
	ErrorCode = 0;        
}
//---------------------------------------------------------------------------

[mark_c]

finally with this version I can experience a collision: apparently a single thread, the previous version of the code, is not enough to cause a collision or, it can happen a collision but in a non-deterministic time

Code: Select all

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"

class TMyThread1 : public TThread
{
protected:
	void __fastcall Execute();
public:
	__fastcall TMyThread1();
	void __fastcall MySincrSock1();
	String msg;
};


class TMyThread2 : public TThread
{
protected:
	void __fastcall Execute();
public:
	__fastcall TMyThread2();
	void __fastcall MySincrSock2();
	String msg;
};

TMyThread1 *Thread1 = NULL;
TMyThread2 *Thread2 = NULL;

//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
	ServerSocket1->Port = 5000;
	ServerSocket1->Active = true;

	ServerSocket2->Port = 5001;
	ServerSocket2->Active = true;
}
//---------------------------------------------------------------------------

__fastcall TMyThread1::TMyThread1()
: TThread(true)
{
}
//---------------------------------------------------------------------------

__fastcall TMyThread2::TMyThread2()
: TThread(true)
{
}
//---------------------------------------------------------------------------

void __fastcall TMyThread1::MySincrSock1()
{
	try{
		for(int actconn = 0; actconn < Form1->ServerSocket1->Socket->ActiveConnections; actconn++)
		{
			Form1->ServerSocket1->Socket->Connections[actconn]->SendText(msg);
			Form1->Caption="1";
		}

	} catch(...) { }
}
//---------------------------------------------------------------------------

void __fastcall TMyThread2::MySincrSock2()
{
	try{
		for(int actconn = 0; actconn < Form1->ServerSocket2->Socket->ActiveConnections; actconn++)
		{
			Form1->ServerSocket2->Socket->Connections[actconn]->SendText(msg);
			Form1->Caption="2";
		}

	} catch(...) { }
}
//---------------------------------------------------------------------------

void __fastcall TMyThread1::Execute()
{
	while (!Terminated)
	{
		for(int i=0; i<10;i++)
		{
			msg.sprintf("Y27.5,1,192.168.1.%d,5694,25,25,127",i);
			Synchronize(&MySincrSock1);

                        Form1->StringGrid1->Cells[1][i]=msg;
			Sleep(100);
			Form1->StringGrid1->Cells[1][i]="";
		}
	}
}
//---------------------------------------------------------------------------

void __fastcall TMyThread2::Execute()
{
	while (!Terminated)
	{
		for(int i=0; i<10;i++)
		{
			msg.sprintf("Y27.5,1,192.168.1.%d,5694,25,25,127",i);
			Synchronize(&MySincrSock2);

                        Form1->StringGrid1->Cells[1][i]=msg;
			Sleep(100);
			Form1->StringGrid1->Cells[1][i]="";
		}
	}
}
//---------------------------------------------------------------------------

void __fastcall TForm1::FormDestroy(TObject *Sender)
{
	delete Thread1;
        delete Thread2;

	ServerSocket1->Active = false;
        ServerSocket2->Active = false;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
	Thread1 = new TMyThread1();
        Thread2 = new TMyThread2();

	Button1->Enabled = false;
	Button2->Enabled = true;

	Caption = "Started.....";

	Thread1->Resume();
        Thread2->Resume();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
	if (Thread1) Thread1->Terminate();
        if (Thread2) Thread2->Terminate();

	Button1->Enabled = true;
	Button2->Enabled = false;

	Caption = "Stopped.....";        
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ServerSocket1ClientError(TObject *Sender,
      TCustomWinSocket *Socket, TErrorEvent ErrorEvent, int &ErrorCode)
{
	Socket->Close();
	ErrorCode = 0;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ServerSocket2ClientError(TObject *Sender,
      TCustomWinSocket *Socket, TErrorEvent ErrorEvent, int &ErrorCode)
{
	Socket->Close();
	ErrorCode = 0;
}
//---------------------------------------------------------------------------

[mark_c]

Hello,
but is it possible to declare and implement the shared methods only once so they can be used by multiple threads?

the method below, for example, is very inconvenient.

Code: Select all

class TMyThread1 : public TThread
{
protected:
	void __fastcall Execute();
public:
	__fastcall TMyThread1();
	void __fastcall MySincrSock();
        void __fastcall MyStringGrid();
	String msg;
        int i;
};


class TMyThread2 : public TThread
{
protected:
	void __fastcall Execute();
public:
	__fastcall TMyThread2();
	void __fastcall MySincrSock();
        void __fastcall MyStringGrid();
	String msg;
        int i;
};

void __fastcall TMyThread1::MyStringGrid()
{
        Form1->StringGrid1->Cells[1][i]=msg;
        if(i > 0)
        Form1->StringGrid1->Cells[1][i-1]="";
}
//---------------------------------------------------------------------------

void __fastcall TMyThread2::MyStringGrid()
{
        Form1->StringGrid1->Cells[1][i]=msg;
        if(i > 0)
        Form1->StringGrid1->Cells[1][i-1]="";
}
//---------------------------------------------------------------------------

[b]void __fastcall TMyThread(n)::MyStringGrid()[/b]
{
        Form1->StringGrid1->Cells[1][i]=msg;
        if(i > 0)
        Form1->StringGrid1->Cells[1][i-1]="";
}
//---------------------------------------------------------------------------

[rlebeau]

but is it possible to declare and implement the shared methods only once so they can be used by multiple threads?

Simply use a single thread class. Your multiple classes are doing the exact same thing, and thus are completely redundant. Just create multiple object instances of the same class.

Code: Select all

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"

class TMyThread : public TThread
{
protected:
	void __fastcall Execute();
public:
	__fastcall TMyThread(int ANum, TServerSocket *AServer);
	void __fastcall MySincrSock();
	String msg;
	int num;
	TServerSocket *server;
};

TMyThread *Thread1 = NULL;
TMyThread *Thread2 = NULL;

//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
	ServerSocket1->Port = 5000;
	ServerSocket1->Active = true;

	ServerSocket2->Port = 5001;
	ServerSocket2->Active = true;
}
//---------------------------------------------------------------------------

__fastcall TMyThread::TMyThread(int ANum, TServerSocket *AServer)
	: TThread(true)
{
	num = ANum;
	server = AServer;
}
//---------------------------------------------------------------------------

void __fastcall TMyThread::MySincrSock()
{
	try{
		for(int actconn = 0; actconn < server->Socket->ActiveConnections; actconn++)
		{
			server->Socket->Connections[actconn]->SendText(msg);
			Form1->Caption = num;
		}

	} catch(...) { }
}
//---------------------------------------------------------------------------

void __fastcall TMyThread::Execute()
{
	while (!Terminated)
	{
		for(int i = 0; i < 10; i++)
		{
			msg.sprintf("Y27.5,1,192.168.1.%d,5694,25,25,127",i);
			Synchronize(&MySincrSock);

			Form1->StringGrid1->Cells[1][i]=msg;
			Sleep(100);
			Form1->StringGrid1->Cells[1][i]="";
		}
	}
}
//---------------------------------------------------------------------------

void __fastcall TForm1::FormDestroy(TObject *Sender)
{
	delete Thread1;
	delete Thread2;

	ServerSocket1->Active = false;
	ServerSocket2->Active = false;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
	Thread1 = new TMyThread(1, ServerSocket1);
	Thread2 = new TMyThread(2, ServerSocket2);

	Button1->Enabled = false;
	Button2->Enabled = true;

	Caption = "Started.....";

	Thread1->Resume();
	Thread2->Resume();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
	if (Thread1) Thread1->Terminate();
	if (Thread2) Thread2->Terminate();

	Button1->Enabled = true;
	Button2->Enabled = false;

	Caption = "Stopped.....";       
}
//---------------------------------------------------------------------------
// you can assign this one handler to BOTH TServerSocket objects!
void __fastcall TForm1::ServerSocketClientError(TObject *Sender,
      TCustomWinSocket *Socket, TErrorEvent ErrorEvent, int &ErrorCode)
{
	Socket->Close();
	ErrorCode = 0;
}
//---------------------------------------------------------------------------

[mark_c]

thanks remy, forgive my curiosity: but are you a teacher?

[rlebeau]

thanks remy, forgive my curiosity: but are you a teacher?

No, I am not. I am a professional software developer.