wird ja eigentlich (sobald eine Zustandsänderung) eintritt die error_flag geändert.
Jetzt muss ich nur noch meinen thread dazubringen, auf diese Änderung zu reagieren.
Lies dir bitte alles zum Thema Memory-Model, Threads, Synchronisierung etc. durch was du finden kannst.
Kurzfassung: nur weil du in einem Thread a = 23; sagst ist noch lange nicht garantiert dass diese Änderung in einem anderen Thread auch "sichtbar" ist. Wenn du die "Sichtbarkeit" erzwingen willst musst du sog. Barriers setzen. Wenn du Mutexen (z.B. CRITICAL_SECTION, MUTEX oder auch pthread_mutex) verwendest hast du diese Barriers automatisch beim Lock/Unlock der Mutex. So macht man es auch üblicherweise (also über Mutexen), Code der direkt Barriers verwendet ist eher verpönt, weil schwer zu schreiben (siehe nächster Absatz, das muss man dann auch irgendwie handhaben), und schwer zu lesen/verstehen. Solange man nur unter mit x86/x86_64 arbeitet geht einem einiges durch, aber sobald man versucht seinen Code auf einem PowerPC oder Alpha oder sonstigem Untier zum Laufen zu bekommen fliegt einem schnell was um die Ohren wo man vorher u.U. nichtmal wusste dass man was falsch macht.
Nächstes Problem: wenn du a = b; sagst, und ein anderer Thread möglicherweise gleichzeitig b ändert, dann ist nicht garantiert dass a danach einen Wert hat der *jemals* in b gestanden hat. Es könnte z.B. sein dass b "in zwei Teilen" gelesen wird, und sich der Wert zwischen dem Lesen von Teil 1 und Teil 2 geändert hat. Dann hätte a danach vielleicht einen Wert wo Bits 0-15 vom alten Wert von b stammen und Bits 16-31 vom neuen Wert von b. Auch das kann man mit Mutexen verhindern, indem man immer nur einem Thread erlaubt auf b zuzugreifen (MUTual EXclusion, kurz: mutex).
Auf dein Beispiel bezogen könnte das ca. so aussehen:
Mutex g_myMutex;
if ((connect(sock,(struct sockaddr *) &address, sizeof(address))) !=0 &&
is_connected==0)
{
check_value=open_socket(Socket_Version, Socket_Data, &socket_inf);
g_myMutex.Lock(); // damit wir auf "error_flag" zugreifen dürfen
error_flag->Error_Flag=WSAGetLastError();
g_myMutex.Unlock(); // damit andere auch wieder drankommen
}
check_value=recv(sock,buf_recieve,BUF,0);
//...
Im Thread dann entsprechend:
DWORD WINAPI handle_error(FLAG *error_flag)
{
for (;;)
{
g_myMutex.Lock(); // damit wir auf "error_flag" zugreifen dürfen
int flag = error_flag->Error_Flag;
g_myMutex.Unlock(); // damit andere auch wieder drankommen
switch (flag)
{
case WSANOTINITIALISED :
//...
}
}
return 0;
}
Das ganze ist allerdings etwas viel zu komplex um es hier zu erklären, und es gibt einige Fallstricke. Deadlocks z.B., um einen der "beliebtesten" zu nennen.