VC++ e MFC: Sono alle prime armi!

[Fabrizio73]

Di (V)C++ e MFC so pochissimo, praticamente nulla e vorrei porre rimedio a qs mia lacuna.

Ho tentanto di realizzare un programmino che crea un thread, il quale si limita a visualizzare un parametro passatogli all'atto della creazione.

#include <iostream.h>
#include <afxwin.h>


UINT threadBody (LPVOID pParam) {
    int* threadParam = (int*) pParam;
	cout << *threadParam << endl;
	return 0;
}


void main (int argc, char* argv[]) {
    int threadParam = 0;
	CWinThread* thread = AfxBeginThread (threadBody, &threadParam);
}

Tuttavia durante il linking ottengo qs errori:

--------------------Configuration: prova - Win32 Debug--------------------
Compiling...
prova.cpp
Linking...
nafxcwd.lib(thrdcore.obj) : error LNK2001: unresolved external symbol __endthreadex
nafxcwd.lib(thrdcore.obj) : error LNK2001: unresolved external symbol __beginthreadex
Debug/prova.exe : fatal error LNK1120: 2 unresolved externals
Error executing link.exe.

prova.exe - 3 error(s), 0 warning(s)

Dov'è il problema?

JAVA dove sei ?

[cionci]

Hai linkato il file senza MFC... Project -> Settings -> General e nel menù a tendina seleziona MFC come shared DLL...

[Fabrizio73]

Thanks ... però il programma non funziona, infatti dovrebbe visualizzare il contenuto di threadParam, ossia 0 ma non visualizza nulla... che altro ho combinato?

[-=Krynn=-]

uh, anche io mi sto scontrando contro quel muro che è la MFC.....
se riesci a risolvere il tuo problema dimelo magari in pvt

[cionci]

Originariamente inviato da Fabrizio73
[b]Thanks ... però il programma non funziona, infatti dovrebbe visualizzare il contenuto di threadParam, ossia 0 ma non visualizza nulla... che altro ho combinato?

Il problema sta nel fatto che il thread che lanci finisce dopo il main...quindi la variabile threadParam non risulta più inizializzata...

Quindi le soluzioni possono essere diverse...

Ad esempio metti una Sleep in fondo al main...oppure la soluzione corretta è usare la WaitForSingleObject...

Il problema è che non so come recuperare l'HANDLE dal CWinThread...ho usato la WaitForSingleObject per molte cose, ma non per i thread...

Una soluzione potrebbe essere creare il thread con
HANDLE CreateThread(
LPSECURITY_ATTRIBUTES lpThreadAttributes, // pointer to security attributes
DWORD dwStackSize, // initial thread stack size
LPTHREAD_START_ROUTINE lpStartAddress, // pointer to thread function
LPVOID lpParameter, // argument for new thread
DWORD dwCreationFlags, // creation flags
LPDWORD lpThreadId // pointer to receive thread ID
);

che come vedi ritorna l'HANDLE da poter usare con la WaitForSingleObject...

[Fabrizio73]

Che SVISTA... hai ragione il main thread termina prima!!!

Ho risolto così:

#include <iostream.h>
#include <afxwin.h>


UINT threadBody (LPVOID pParam) {
    int* threadParam = (int*) pParam;
    cout << *threadParam << endl;
    return 0;
}


void main (int argc, char* argv[]) {
    int threadParam = 0;
    CWinThread* thread = AfxBeginThread (threadBody, &threadParam);
    [B]HANDLE threadHandle = (*thread).m_hThread;
    ::WaitForSingleObject (threadHandle, INFINITE);[/B]
}

Grazie 1000

Cionci for Moderator

[Fabrizio73]

Mi sta venendo un dubbio... se il thread creato invece, terminasse prima che il main thread riuscisse a recuperare l'handle... che accadrebbe?

Forse sarebbe il caso di creare il thread in modalità suspended, recuperare l'handle (o duplicare l'handle?) e quindi effettuare il resume!

E' giusto?

[Fabrizio73]

#include <iostream.h>
#include <afxwin.h>


UINT threadBody (LPVOID pParam) {
    int* threadParam = (int*) pParam;
    cout << *threadParam << endl;
    return 0;
}


void main (int argc, char* argv[]) {
    int threadParam = 0;
    CWinThread* thread = AfxBeginThread (threadBody, &threadParam,
                                         THREAD_PRIORITY_NORMAL, 0, CREATE_SUSPENDED);
    HANDLE threadHandle;
    ::DuplicateHandle (GetCurrentProcess (), (*thread).m_hThread,
                       GetCurrentProcess (), &threadHandle, 0, FALSE, DUPLICATE_SAME_ACCESS);
    (*thread).ResumeThread ();
    ::WaitForSingleObject (threadHandle, INFINITE);
    ::CloseHandle (threadHandle);
}

Possibile che si debba fare tutto questo casino?
Java diventa sempre più il mio preferito...

[Fabrizio73]

Ho trovato una soluzione più bella : impedire alla MFC di distruggere l'oggetto CWinThread quando esso termina, in questo modo si può recuperare l'handle a patto di distruggere "manualmente" l'oggetto...

#include <iostream.h>
#include <afxwin.h>


UINT threadBody (LPVOID pParam) {
    int* threadParam = (int*) pParam;
    cout << *threadParam << endl;
    return 0;
}


void main (int argc, char* argv[]) {
    int threadParam = 0;
    CWinThread* thread = AfxBeginThread (threadBody, &threadParam,
                                         THREAD_PRIORITY_NORMAL, 0, CREATE_SUSPENDED);
    (*thread).m_bAutoDelete = FALSE;
    HANDLE threadHandle = (*thread).m_hThread;
    (*thread).ResumeThread ();
    ::WaitForSingleObject (threadHandle, INFINITE);
    delete thread;
}

[cionci]

Vabbè...niente male...

[cionci]

Originariamente inviato da Fabrizio73
[b]Mi sta venendo un dubbio... se il thread creato invece, terminasse prima che il main thread riuscisse a recuperare l'handle... che accadrebbe?

Ma sinceramente credo che se fa un WaitForSingleObject su un HANDLE non più valido esca subito...

[Fabrizio73]

Scusatemi se vi annoio ancora ... ma ho un altro problemino .

Ho realizzato qs classe:

class Client
{
	private:
		double interArrivalMeanTime;
		Queue* queue;
		BOOL isInterrupted;
		CWinThread* thread;
		UINT threadBody (LPVOID pParam);
	public:
		Client (double interArrivalMeanTime, Queue* queue);
		~Client ();
		void start ();
		void interrupt ();
};


UINT Client::threadBody (LPVOID pParam)
{
	// Corpo del thread...
	return 0;
}


Client::Client (double interArrivalMeanTime, Queue* queue)
{
	(*this).interArrivalMeanTime = interArrivalMeanTime;
	(*this).queue = queue;
	isInterrupted = FALSE;
	[COLOR=RED]thread = AfxBeginThread (threadBody, NULL, THREAD_PRIORITY_NORMAL, 0, CREATE_SUSPENDED);[/COLOR]
	(*thread).m_bAutoDelete = FALSE;
}


Client::~Client ()
{
	delete thread;
}


void Client::start ()
{
	(*thread).ResumeThread ();
}


void Client::interrupt ()
{
	isInterrupted = TRUE;
}

All'atto della compilazione, viene segnalato il seguente errore sulla linea di codice in rosso:

error C2665: 'AfxBeginThread' : none of the 2 overloads can convert parameter 1 from type 'unsigned int (void *)'

Se invece definisco la classe Client in qs modo, ossia faccio in modo che la funzione threadBody sia globale...

class Client
{
	private:
		double interArrivalMeanTime;
		Queue* queue;
		BOOL isInterrupted;
		CWinThread* thread;
	public:
		Client (double interArrivalMeanTime, Queue* queue);
		~Client ();
		void start ();
		void interrupt ();
};


[COLOR=BLUE]UINT threadBody (LPVOID pParam)
{
	// Corpo del thread...
	return 0;
}[/COLOR]


Client::Client (double interArrivalMeanTime, Queue* queue)
{
	(*this).interArrivalMeanTime = interArrivalMeanTime;
	(*this).queue = queue;
	isInterrupted = FALSE;
	thread = AfxBeginThread (threadBody, NULL, THREAD_PRIORITY_NORMAL, 0, CREATE_SUSPENDED);
	(*thread).m_bAutoDelete = FALSE;
}


Client::~Client ()
{
	delete thread;
}


void Client::start ()
{
	(*thread).ResumeThread ();
}


void Client::interrupt ()
{
	isInterrupted = TRUE;
}

...non viene segnalato alcun errore di compilazione!

Cosa non va ?

[cionci]

Prova a definire la funzione threadBody come static UINT ThreadBody(LPVOID pParam)...

[cionci]

Guarda un po'...questa sembra funzionare bene...

#include <iostream.h>
#include <afxwin.h>


typedef char Queue;

class Client
{
	private:
		double interArrivalMeanTime;
		Queue* queue;
		BOOL isInterrupted;
		CWinThread* thread;
		static UINT threadBody2 (LPVOID pParam);
	public:
		Client (double interArrivalMeanTime, Queue* queue);
		~Client ();
		void start ();
		void interrupt ();
};


UINT Client::threadBody2 (LPVOID pParam)
{
	// Corpo del thread...

	cout << ((Client*)pParam)->interArrivalMeanTime << endl;
	return 0;
}


Client::Client (double interArrivalMeanTime, Queue* queue)
{
	(*this).interArrivalMeanTime = interArrivalMeanTime;
	(*this).queue = queue;
	isInterrupted = FALSE;
	thread = AfxBeginThread (threadBody2, this, THREAD_PRIORITY_NORMAL, 0, CREATE_SUSPENDED);
	(*thread).m_bAutoDelete = FALSE;
}


Client::~Client ()
{
	delete thread;
}


void Client::start ()
{
	(*thread).ResumeThread ();
}


void Client::interrupt ()
{
	isInterrupted = TRUE;
}

UINT threadBody (LPVOID pParam) {
    int* threadParam = (int*) pParam;
	cout << *threadParam << endl;
	return 0;
}


void main (int argc, char* argv[]) {
    int threadParam = 0;

	Client *thread[5];

	for(int i=0; i<5; ++i)
	{
		thread[i] = new Client((double)i,0);
		thread[i]->start();
	}
	Sleep(300);
}

[Fabrizio73]

Bhé... che dire... sei un genio ... ma xché è necessario dichiarare la funzione di controllo del thread static?

[cionci]

Forse perchè gli indirizzi delle funzioni vengono tradotti al tempo della compilazione quindi non essendo static (cioè c'è una sola istanza di quella funzione valida per tutte le classi) non può determinare a priori a quale istanza della classe ti riferisci...

[Fabrizio73]

Non fa una grinza !!!

Ascolta un po'... in Java esistono due comodissime funzioni, molto utili in problemi del tipo produttore/consumatore. Mi riferisco alle funzioni wait () e notify () (esiste anche notifyAll ()). Esiste qualcosa di simile in VC++/MFC?

[cionci]

Spiegami un po' il significato...anche se un po' mi sembra di capirlo...

[Fabrizio73]

Ti faccio un esempio. Supponiamo di voler simulare un sistema client/server assegnando ad un thread il compito del client e ad un altro il compito del server. Il client formula le richieste inserendole in una coda (queue). Il server non fa altro che estrarre le richieste dalla coda ed eseguirle.

Per evitare che il server esegua un'attesa attiva sulla coda (ossia controlli continuamente se vi sono richieste), esso può invocare il metodo wait dell'oggetto queue e si addormenta:

synchronized (queue) {
    if (queue.isEmpty ()) {
        queue.wait ();
    }
    request = (Request)queue.get ();
}

Quando il client inserisce una richiesta nella coda, provvede a risvegliere il thread server invocando il metodo notify dell'oggetto queue:

synchronized (queue) {
    queue.put (request);
    queue.notify ();
}

C'è da dire che in Java ogni classe possiede di default alcuni metodi fra i quali ci sono wait e notify, per cui non è necessario definire qs funzioni quando si definisce la classe.

Inoltre un thread per poter invocare la wait di un oggetto, deve possedere il lock su tale oggetto (synchronized). Quando la wait viene invocata il lock sull'oggetto viene automaticamente rilasciato per evitare deadlock.

Carino... no?

Tutto questo è possibile in VC++/MFC?

[cionci]

In pratica che nei sistemi oeprativi si chiama semaforo ?!?!?

CMultiLock does not have a base class.

An object of class CMultiLock represents the access-control mechanism used in controlling access to resources in a multithreaded program. To use the synchronization classes CSemaphore, CMutex, and CEvent, you can create either a CMultiLock or CSingleLock object to wait on and release the synchronization object. Use CMultiLock when there are multiple objects that you could use at a particular time. Use CSingleLock when you only need to wait on one object at a time.

To use a CMultiLock object, first create an array of the synchronization objects that you wish to wait on. Next, call the CMultiLock object’s constructor inside a member function in the controlled resource’s class. Then call the Lock member function to determine if a resource is available (signaled). If one is, continue with the remainder of the member function. If no resource is available, either wait for a specified amount of time for a resource to be released, or return failure. After use of a resource is complete, either call the Unlock function if the CMultiLock object is to be used again, or allow the CMultiLock object to be destroyed.

CMultiLock objects are most useful when a thread has a large number of CEvent objects it can respond to. Create an array containing all the CEvent pointers, and call Lock. This will cause the thread to wait until one of the events is signaled.

For more information on how to use CMultiLock objects, see the articleMultithreading: How to Use the Synchronization Classes in Visual C++ Programmer’s Guide.