Parameterübergabe in einem Thread??

l00P

hi!

Kann ich einer Funktion die in einem Thread aufgerufen wird einen Parameter übergeben? Wenn ja, wie??

Der Methode sendFile würde ich gerne einen CString übergeben....

void Transaction::doSend()
{
	///Create a thread for sending data   
	//
	//
	CWinThread * Callback_Thread;
    Callback_Thread = AfxBeginThread(
               ThreadSend,               // function to run on thread
               (LPVOID)this,                // value to pass to function
               THREAD_PRIORITY_NORMAL,   // thread's priority
               0,                        // stack size
               CREATE_SUSPENDED,         // create susupended thread
               NULL);               

	//start thread
	Callback_Thread->ResumeThread();

//	MessageBox(NULL, (CString)"thread!", "WuffBox_Dbg", MB_OK);

}

UINT ThreadSend(LPVOID  xthis)
{
	int tsg_return = 0;

	Transaction* _this = (Transaction*)xthis;
	tsg_return = _this->sendFile();
	return 0;
}

Rapha

Hi

versteh deine Frage nicht ganz

UINT ThreadSend(LPVOID  xthis) 
{ 
    int tsg_return = 0; 
     Transaction* _this = (Transaction*)xthis; 
    CString strFile = "C:\\test.txt";
    tsg_return = _this->sendFile(strFile); 
    return 0; 
}

Grüße Rapha

l00P

ja danke, dachte mal wieder ein bißchen ums Eck

Andere Frage: Ich habe einen Thread gestartet mit sagen wir der Function doSend();
wie kann ich diese function aufrufen ohne immer einen neuen thread aufzumachen?? oder ist es besser den thread jedesmal zu terminieren und einen neuen zu erstellen wenn ich diese function brauche??

danke
l00P

Rapha

Hi

muss nochmal etwas genauer nachfragen

Ich habe einen Thread gestartet mit sagen wir der Function doSend();

Wie meinst du das? Ist doSend() die Threadfunktion (verwendest du also AfxBeginThread(doSend,...)) [Fall 1] oder startest du in dieser Funktion den Thread (mit AfxBeginThread(ThreadFunc...)) [Fall 2].

wie kann ich diese function aufrufen ohne immer einen neuen thread aufzumachen??

bei [Fall 1]
ganz normal also mit

doSend(und_den_parameter_den_du_selbst_bestimmt_hast);

Die Funktion läuft dann halt in dem Thread, von dem du sie aufgerufen hast (normalerweise der Hauptthread).

bei [Fall 2]
Du übergibst der Funktion einfach einen Parameter (bool), der bestimmt, ob der "Inhalt" der Funktion in einem neuen Thread laufen soll, oder im selben, von dem die Funktion aufgerufen wurde.

oder ist es besser den thread jedesmal zu terminieren und einen neuen zu erstellen wenn ich diese function brauche??

Ich würde sagen, kommt drauf an, was der Thread macht. Wenn er z.B. in eine Datei schreibt, dann musst du den vorherigen Thread beendet, sonst gibts ein kuddelmuddel :p

Grüße Rapha

l00P

danke, kenn mich aus soweit....

bloß noch: Wird bei jedem Aufruf von resumeThread() der therad neu gestartet oder nur weitergeführt??

lg
l00P

Rapha

Hi

wenn du ResumeThread auf einen angehaltenen Thread (SuspendThread()) aufrufst, wird der Thread (genauer gesagt die Threadfunktion) neu gestartet.
Ich bin mir zwar ziemlich sicher, geb dir aber keine Garantie

Grüße Rapha

guelling

Bin mir ziemlich sicher, das der Thread dann an der selben Stelle weitermacht.

Egal, ich wollte eine Frage zur eigentlichen Topic stellen.
Möchte beim Aufruf von axfbeginthread eine simple integer-Variable übergeben.
Irgendwo im Netz habe ich gefunden, dass es so wohl gehen könnte:

int neu=6;
pThread1 = AfxBeginThread(thrFunction1,(LPVOID)&neu);

UINT CThreadTestDlg::thrFunction1(LPVOID pParam)  
{  
  CThreadTestDlg* pDlg = (CThreadTestDlg*) pParam;
  int test=(int)pParam;
  pDlg->thrRun1(test);  
  return 0;  
}

Die Funktion thrRun1 brauche ich dann für meinen eigentlichen Kram.
Leider kommt beim ausführen eine Fehlermeldung. Warum?
Bin mir auch bei dem '&' vor neu nicht sicher.

RHBaum

UINT CThreadTestDlg::thrFunction1(LPVOID pParam)   
{   
  CThreadTestDlg* pDlg = (CThreadTestDlg*) pParam; 
  int test=(int)pParam; 
  pDlg->thrRun1(test);   
  return 0;   
}

Omg, was machst du den hier ?

pThread1 = AfxBeginThread(thrFunction1,(LPVOID)&neu);

ok, dein pParam ist also nen zeiger auf nen int ...

CThreadTestDlg* pDlg = (CThreadTestDlg*) pParam;

du versuchst nen int* auf nen CThreadTestDlg* zu casten, aua !
und auch noch boeser c-Cast !!!

besser, gib deinem CThreadTestDlg nen member als int ... also von miraus, int neu; kann private sein ....

neu=6; // Member, du rufst sicher deinen thread aus dem dialog auf ... 
pThread1 = AfxBeginThread(thrFunction1,this); // sollte kein cast noetig sein !

]

UINT CThreadTestDlg::thrFunction1(LPVOID pParam)   
{   
  CThreadTestDlg* pDlg = reinterpret_cast<CThreadTestDlg*>(pParam); 
  int test=pParam->neu; // erriner dich, dein int war nu member am dialog
  pDlg->thrRun1(test); // Da du den zeiger auf den dialog hasst, kannst da auch funktionen aufrufen   
  return 0;   
}

guelling

Hmm, das mit der Membervariable ist ungünstig.
Ich rufe diese Funktion mehrmals in Schleifen auf, jedesmal soll ein bestimmter Parameter übergeben werden. Ausserdem lief es ja schon mal alles, bevor ich zu MFC gewechselt bin.

So funktioniert es ja:

pThread1 = AfxBeginThread(thrFunction1,this);

UINT CThreadTestDlg::thrFunction1(LPVOID pParam)   
{   
  CThreadTestDlg* pDlg = (CThreadTestDlg*) pParam; 
  pDlg->thrRun1();   
  return 0;   
}

Aber der gewünschte int-Parameter fehlt.
Vorher sah es so aus:

DWORD WINAPI thrRun1(LPVOID pParam)
{
  int test=(int)pParam;
  ...
  return((DWORD)pParam);
}

int neu=5;
::pThread1 = CreateThread(	NULL,0,thrRun1,(LPVOID)neu,0,&::Thread1ID);

Leider müssen die Thread-Start-Funktionen ja statisch sein, sobald sie in einer Klasse sind, deswegen brauche ich die jetzige Konstruktion um wieder eine nichtstatische Funktion aufzurufen.
Was habe ich für Möglichkeiten den ersten Code dasselbe tun zulassen wie den zweiten?