hi,
folgendes problem:
die ausgabe ist nicht korrekt, ich kann mir auch schon denken woran es liegt.
die threads sind nicht synchronisiert. da liegt aber auch mein problem, nach code beispielen die kommentiert sind, hab ich schon im netz gesucht, leider ist das ergebnis mager ausgefallen. ausser das tutorial von www.codeworx.org konnte mir einen kleinen einblick verschaffen.
jedoch ist auch das codeworx tutorial dürftig. deshalb frage ich euch, ob ihr mir helfen könnt zb den obigen code thread safe zu programmieren, mir vielleicht unterstützung geben, da die threadprogrammierung zur zeit ein wichtiges thema für mich ist.

gruß xerxes

Microsoft Windows Programmierung für Experten | ISBN: 3860636154

Hepi schrieb:

Wenn Du bereit bist, etwas Geld zu investieren, kann ich Dir nur den Richter ans Herz legen. Da wird das bis zum Abwinken durchgekaut...

das wollte ich mir schon kaufen, doch 100€ bei amazon ist mir doch etwas zu viel
das würde mein budget nicht mitmachen, vielleicht sollte ich mal meinen chef fragen, der könnte es finanzieren

CMatt schrieb:

was ist denn in deinen augen ne korrekte ausgabe?

folgendes:
die ausgabe heisst "ich bin 1" oder "ich bin 0"
es kommt vor das zb "iiiiccch bbbiiin 1111" ausgegeben wird. das ist schlicht weg falsch. die ausgabe mag zwar richtig sprich die threads geben immer "ich bin 1" oder "ich bin 0" aus. doch am ende kommt manchmal eben so eine mischung raus
das habe ich mit falscher ausgabe definiert

gruß xerxes

bau ne globale critsect namens coutCritsect und mach immer vor cout<<bla ein entern und danach ein leaven.

nach dem ausführen wird nur "Threads gestartet..." ausgeben und dann erscheint nichts mehr. hab ich den kritischen abschnitt richtig angewandt?

gruß xerxes

ausgabe: es wird im abstand von 200 milisekunden immer "ich bin 1" oder "ich bin
0" ausgegeben. ich würde nur gerne wissen welcher thread gerade schreibt. ich hab die vermutung das nicht alle threads die erlaubnis bekommen zu schreiben.
gruß xerxes

edit: hier ein screenshot zur programmlaufzeit screenshot

nach dem ausführen wird nur "Threads gestartet..." ausgeben und dann erscheint nichts mehr. hab ich den kritischen abschnitt richtig angewandt?

gruß xerxes

Nein hast Du nicht (hast die CriticalSection nicht initialisiert, außerdem sollte sie global sein damit alle Threads drauf zugreifen können...

#include <iostream>
#include <windows.h>
#include <stdio.h>
#include <winbase.h>

//#pragma comment(lib, "coremain.lib")

#define MAX_THREADS 10

using namespace std;

DWORD WINAPI ThreadFunc(LPVOID data);

CRITICAL_SECTION csMyCriticalSection;

int main()
{	
	HANDLE hThread[MAX_THREADS];			// Handles auf die Threads
	DWORD  dwThreadID[MAX_THREADS];		// IDs der Threads

    InitializeCriticalSection(&csMyCriticalSection);

	int ThreadPara = 2;

	int a = 1;
	int *p = &a;

	for(int i = 0; i < MAX_THREADS; i++)
		hThread[i] = CreateThread(NULL, 0, ThreadFunc, (LPVOID)p, 0, &dwThreadID[i]);

	cout << "Threads gestartet..." << endl;

	while(true)
	{
		*p != 0 ? *p = 0 : *p = 1;
		Sleep(2000);
	}

	for (i = 0; i < MAX_THREADS; i++)
		CloseHandle(hThread[i]);

    DeleteCriticalSection(&csMyCriticalSection);
	return 0;
}

DWORD WINAPI ThreadFunc(LPVOID data)
{
	int *p = (int*) data;

	while(1)
	{
		if(*p != 0)
		{	
			EnterCriticalSection (&csMyCriticalSection);
			cout << "ich bin 1" << endl;
			LeaveCriticalSection (&csMyCriticalSection);
			Sleep(1000);
		}

		else
		{
			EnterCriticalSection (&csMyCriticalSection);
			cout << "ich bin 0" << endl;
			LeaveCriticalSection (&csMyCriticalSection);
			Sleep(1000);
		}
	}

	DeleteCriticalSection(&csMyCriticalSection);

	return ((DWORD) data);
}

#include <iostream>
#include <windows.h>
#include <stdio.h>
#include <winbase.h>

//#pragma comment(lib, "coremain.lib")

#define MAX_THREADS 10

using namespace std;

DWORD WINAPI ThreadFunc(LPVOID data);

void EnterCoutSection(void);
void LeaveCoutSection(void);

// Thread_Die sagt ob alle Threads sterben sollen odernicht
bool Thread_Die = false;

bool CoutMutex = false;

int main()
{	
	HANDLE hThread[MAX_THREADS];			// Handles auf die Threads
	DWORD  dwThreadID[MAX_THREADS];		// IDs der Threads

	int ThreadPara = 2;

	int a = 1;
	int *p_a = &a;

	for(int i = 0; i < MAX_THREADS; i++)
		hThread[i] = CreateThread(NULL, 0, ThreadFunc, (LPVOID)p_a, 0, &dwThreadID[i]);

	cout << "Threads gestartet..." << endl;

	for(i = 1; i < 201; i++)
	{
		*p_a = i;
		Sleep(100);
	}

	Thread_Die = true;

/*	WaitForMultipleObjects(	MAX_THREADS,	
							hThread,		
							TRUE,			
							INFINITE);	    

	Thread_Die = true;*/

	for (i = 0; i < MAX_THREADS; i++)
		CloseHandle(hThread[i]);

	cout << endl;
	return 0;
}

DWORD WINAPI ThreadFunc(LPVOID data)
{
	int *p = (int*) data;

	while(!Thread_Die)
	{
		if(*p != 0)
		{
			EnterCoutSection();

			Sleep(100);
			cout << *p << endl;

			LeaveCoutSection();
		}

		else 
			break;

		Sleep(100);
	}

	return ((DWORD) data);
}

void EnterCoutSection(void)
{
	while(true)
	{
		if(!CoutMutex)
		{
			CoutMutex = true;
			break;
		}

		Sleep(100);
	}
}

void LeaveCoutSection(void)
{
	CoutMutex = false;
}

was mich beim folgenden code verwirrt, ist, dass stets die reihenfolge der zahlenreiche eingehalten wird.

Was wundert dich daran? Es greifen doch alle Threads auf dieselbe Adresse zu

#include <iostream>
#include <windows.h>
#include <stdio.h>
#include <winbase.h>
#include <sstream>

//#pragma comment(lib, "coremain.lib")
#pragma comment(lib, "ws2_32.lib")
#define MAX_THREADS 10

using namespace std;

DWORD WINAPI ThreadFunc(LPVOID data);

void EnterCoutSection(void);
void LeaveCoutSection(void);

string convert_int(int convert);

// Thread_Die sagt ob alle Threads sterben sollen odernicht
bool Thread_Die = false;

bool CoutMutex = false;

int main()
{   
   HANDLE hThread[MAX_THREADS];         // Handles auf die Threads
   DWORD  dwThreadID[MAX_THREADS];      // IDs der Threads

   int ThreadPara = 2;

   string ip;   
   string *p_ip = &ip;

   WORD wVersionRequested;
   WSADATA wsaData;
   wVersionRequested = MAKEWORD( 2, 2);

   WSAStartup( wVersionRequested, &wsaData );

   for(int i = 0; i < MAX_THREADS; i++)
      hThread[i] = CreateThread(NULL, 0, ThreadFunc, (LPVOID)p_ip, 0, &dwThreadID[i]);

   cout << "Threads gestartet..." << endl;

   for(i = 0; i < 256; i++)
   {
      string temp;
      temp = convert_int(i);

      *p_ip = "213.147.0." + temp;   
      Sleep(100);
   }

   Thread_Die = true;

/*   WaitForMultipleObjects(   MAX_THREADS,   
                     hThread,      
                     TRUE,         
                     INFINITE);      

   Thread_Die = true;*/

   for (i = 0; i < MAX_THREADS; i++)
      CloseHandle(hThread[i]);

   cout << endl;
   return 0;
}

DWORD WINAPI ThreadFunc(LPVOID data)
{
   string *p = (string*) data;

   HOSTENT *host;
   in_addr inet;

   while(!Thread_Die)
   {
      inet.S_un.S_addr = inet_addr(p->c_str());

      host = gethostbyaddr((const char*) &inet, 4, AF_INET);

      EnterCoutSection();

      cout << *p << " = " << host->h_name << endl;

      LeaveCoutSection();   

      Sleep(10);
   }

   return ((DWORD) data);
}

void EnterCoutSection(void)
{
   while(true)
   {
      if(!CoutMutex)
      {
         CoutMutex = true;
         break;
      }

      Sleep(5);
   }
}

void LeaveCoutSection(void)
{
   CoutMutex = false;
}

string convert_int(int convert_int)
{
   stringstream str;
   string foo;

   str << convert_int;
   str >> foo;

   return foo;
}

void EnterCoutSection(void)
{
   while(true)
   {
      if(!CoutMutex)
      {
         CoutMutex = true;
         break;
      }
      
      Sleep(5);
   }
}

void LeaveCoutSection(void)
{
   CoutMutex = false;
}

Lass dir sowas bloß nicht aufschwätzen! Wenn dein Thread genau zwischen if(!CoutMutex) und CoutMutex=true unterbrochen wird, und zufällig gerade ein anderer Thread ebenfalls CoutMutex sperren will, dann hast du zwei Threads gleichzeitig in dem geschützten Bereich herumschreiben. Wenn du unbedingt etwas Hausgemachtes willst, also keine CRITICAL_SECTION verwenden willst, dann bitte etwas in dieser Art:

LONG CritSect = FALSE;

void EnterCoutSection()
{
   while(InterlockedExchange(&CritSect, TRUE) != FALSE)
      Sleep(0);
}

void LeaveCoutSection()
{
   InterlockedExchange(&CritSect, FALSE);
}