Hallo,

ich habe ein Programm, bestehend aus zwei Threads ThInkr() und ThEing().

Die main() soll diese beiden Threads aufrufen.

ThInkr() inkrementiert einen Zähler alle 15ms.

ThEing() nimmt Eingaben entgegen. Bei einer Eingabe von t soll ein Zähler gestartet werden. Dieser zählt solange, bis wieder t eingegeben wird. Die verstrichene Zeit soll nun ausgegeben werden. Mein Code funktioniert aber nicht. Wo ist das Problem? (siehe roten Text) Es wäre wahrscheinlich sinnvoll ThInkr() irgendwie dafür zu nutzen. Aber wie?

Wäre schon für eine kleine Hilfestellung dankbar.

#include <windows.h>

#include <stdio.h>

#include <process.h>

#include <conio.h>


DWORD zaehler = 0;

unsigned _stdcall ThInkr(void*);

unsigned _stdcall ThEing(void*);

bool abbruch = false;


void main ()


{

	unsigned int tId, tId2;


	zaehler = 95;

	DWORD arg, arg2;

	DWORD wait, wait2;

	HANDLE hp, hp2;


	hp = (HANDLE)_beginthreadex(NULL,0,ThInkr,(void*)arg, 0,&tId );

	if (hp == NULL) printf("\n Error ThInkr");


	hp2= (HANDLE)_beginthreadex(NULL,0,ThEing,(void*)arg2,0,&tId2);

	if (hp2 == NULL) printf("\n Error ThEing");


} 




unsigned _stdcall ThInkr(void* n)


{	

	do {

	  zaehler++;

	  Sleep(15);

	}

	while (!abbruch);


	_endthreadex(0);


	return 0;

} 




unsigned _stdcall ThEing(void* n)


{	

	char input;


    do {

	  printf("\n Bitte Ihre Eingabe: ");

	  input = getch(); 


	  switch (input) {

	    case 'a': printf("\n Zaehler: %d ",zaehler);

				  break;

		case 'b': abbruch = true;

				  break;

	[color=red]	case 't': do				  

				  {

					Sleep(1);

					zaehler++;

				  }

				  while (input == 't');

				  printf("\n Zeit zwischen den beiden Eingaben in ms: %d ",zaehler);

				  break; [/color]

		default : printf("\n Falsche Eingabe! ");

				  break;

	  } // Ende Switch

	}

	while (!abbruch);

	printf("\n Fertig!");


	_endthreadex(1);


	return 0;

}

Drei Tipps von mir:

1.

Wenn deine main-Funktion beendet ist, endet auch dein Programm.

2.

Du kannst mit Sleep keine genaue Zeitsteuerung hinbekommen. Sleep sorgt dafür, dass der aufrufende Thread frühestens nach der angegebenen Zeitspanne wieder ausgeführt wird. Es kann aber durchaus auch später sein - bei Dir wird es immer später sein. Beim Multitasking werden ja erstmal die anderen Threads ausgeführt. Wenn die unter Volllast laufen, nutzen sie ihre ganze Zeitscheibe aus, bis der Windows-Scheduler auf den nächsten Thread wechselt. Allgemein ist die Auflösung der Sleep-Anweisung maximal nur so groß wie die Zeitscheibe des Betriebssystems.

3.

Wenn du mit Threads zu tun hast, verlässt du die Welt von Standard-C++. Daher verschoben: -> C++: Compiler, IDEs, APIs

Danke erstmal für die Tipps.

Zu 1:

Ja, ich weiss, dass mit mit Beendigung von main() mein Programm endet. Warum sagst Du mir das? Hab ich da etwa noch'n schwerwiegenden Fehler drin?

Der Source beinhaltet noch zwei WaitForSingleObject, was ich aber der Übersicht halber hier rausgelassen habe.

Zu 2:

Wenn ich es mit Sleep() nicht machen kann... was habe ich dann für eine Möglichkeit?

Zu 3:

Sorry, wusst ich nicht. Kann nur selten zwischen diesen beiden Foren differenzieren. :floet:

Ja, ich weiss, dass mit mit Beendigung von main() mein Programm endet. Warum sagst Du mir das? Hab ich da etwa noch'n schwerwiegenden Fehler drin?

Der Source beinhaltet noch zwei WaitForSingleObject, was ich aber der Übersicht halber hier rausgelassen habe.

Mit Wait ist es ok. Ich war mir nicht sicher, ob dir klar war, dass deine Threads sofort wieder beendet werden, wenn main beendet ist.

Wenn ich es mit Sleep() nicht machen kann... was habe ich dann für eine Möglichkeit?

Wenn es dir nur um die Zeitmessung geht, und du sowieso nur unter Windows zu Gange bist, brauchst du keine Threads. Du kannst mit GetTickCount aus windows.h die verstrichenen Millisekunden seit dem Start des Systems heraus finden. Wenn du diesen Wert zweimal holst und die Werte voneinander abziehst, hast du den zeitlichen Unterschied der Aufrufe. Beachte aber, dass die Auflösung von GetTickCount auch nur bei etwa 50 ms liegt. Wenn du es genauer brauchst, musst du das wieder anders machen. Stichwort PerformaceCounter.

Wenn es nicht nur um die Zeitmessung geht, dann solltest du dir die üblichen Synchronisierungsobjekte anschaufen: Critical Section, Mutex, Semaphore, Event.

Sorry, wusst ich nicht. Kann nur selten zwischen diesen beiden Foren differenzieren. :floet:

Macht ja nichts