Newsgroup: it.comp.programmare.win32
Titolo: MultiThreading Worker Thread

Sto impazzendo per capire come fare per realizzare un'applicazione
multithreading di worker thread
Programmo in VC++ e non sono riuscito a trovare dei riferimenti ma solo
accenni che non spiegano in concreto cosa fare.
Alquanto incasinata è la non netta separazione (per me che non ci sto
capendo molto) tra le funzioni con approccio API,  MFC e C++.
Se qualcuno potesse darmi delucidazioni sarei molto grato.
Molto graditi sarebbero dei listati di esempio o anche dei listati di
programmi in cui vengono usati worker thread

,

Il VC++ confonde, perche' molti credono che si possa usare il mouse
per scrivere del codice, il che' non e' quasi mai vero.
La distinzione tra funzioni con 'approccio' API , MFC e C++ mi e'
ocura. Al piu' posso capire che le MFC offrano una encapsulazione
delle API, ma il C++ non ha molto a che spartire con i thread
(a differenza di Java, che con l'interfaccia Runnable definita
nello standard qualche _piccola_ relazione tra linguaggio e thread
la possiede).
Un "worker thread" e' un concetto abbastanza generico per definire
un modo di progettare gli applicativi in cui la parte di codice che
svolge operazioni potenzialmente "lunghe" viene separata  dalla parte
di gestione della interfaccia utente.
Esempio: stai scrivendo un FTP client e vuoi dare all'utente la
possibilita' di interrompere il download.
Se il thread che sta svolgendo una "recv(socket, ecc )" e' lo
stesso che processa la coda dei messaggi con gli eventi di mouse e
tastiera, l'utente non ha la possibilita' di premere nessun pulsante
dopo quello di download.
Altro esempio: il tuo programma richiede un disegno complesso
e non si vuole fare attendere l'utente perche' un refresh venga
completato.
In questi casi si usa un "worker thread" (che deve essere oportunamente
sincronizzato con la parte "di interfaccia" della applicazione).
Tipicamente si creano un evento, ed un thread.
Il thread aspetta sull'evento, che diventa il "comando per fare
qualcosa". Quando la logica del tuo programma richiede un "lavoro
in background", si segnala l'evento e si lascia che il thread "worker"
faccia il suo lavoro, sincronizzandosi opportunamente
sul "completamento" del lavoro.
E' difficile scrivere un pezzo di codice e postarlo che sia abbastanza
generico, perche' il worker thread e' tipicamente nel dominio
della tua applicazione, e non nel dominio del linguaggio usato,
o nel dominio delle API (al piu' ti posso suggerire CreateThread() :-))
Sent via Deja.com 
http://www.deja.com/
Share what you know. Learn what you don't.

 wrote in message
news:7le4ak$lbd$1...@nslave1.tin.it...
: Sto impazzendo per capire come fare per realizzare un'applicazione
: multithreading di worker thread
: Programmo in VC++ e non sono riuscito a trovare dei riferimenti ma solo
: accenni che non spiegano in concreto cosa fare.
: Alquanto incasinata è la non netta separazione (per me che non ci sto
: capendo molto) tra le funzioni con approccio API,  MFC e C++.
: Se qualcuno potesse darmi delucidazioni sarei molto grato.
: Molto graditi sarebbero dei listati di esempio o anche dei listati di
: programmi in cui vengono usati worker thread
:
Ti riporto una classe che ho scritto per gestire un worker thread continuo
(non si auto termina). Nel caso tu voglia un thread che viene terminato
automaticamente alla fine delle operazioni devi introdurre alcune
modifiche...
massimo
... file header ...
// RunnerThread.h: interface for the RunnerThread class.
//
//////////////////////////////////////////////////////////////////////
#if
!defined(AFX_RUNNERTHREAD_H__C19445A0_3866_11D3_A7CF_00A0243E9F2B__INCLUDED_
)
#define AFX_RUNNERTHREAD_H__C19445A0_3866_11D3_A7CF_00A0243E9F2B__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
class RunnerThread
{
public:
 bool Close();
 bool Open();
public:
 RunnerThread();
 virtual ~RunnerThread();
private:
    // friend in modo che possa accedere a attributi e metodi della classe
 friend DWORD WINAPI ThreadFunction(RunnerThread* parent);
private:
 bool _closeThread;
 DWORD _thread_id;
 HANDLE _thread;
};
#endif //
!defined(AFX_RUNNERTHREAD_H__C19445A0_3866_11D3_A7CF_00A0243E9F2B__INCLUDED_
)
... file sorgente ...
// RunnerThread.cpp: implementation of the RunnerThread class.
//
//////////////////////////////////////////////////////////////////////
#include "RunnerThread.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
//////////////////////////////////////////////////////////////////////
//
DWORD WINAPI ThreadFunction(RunnerThread* parent)
{
 do {
    // operazioni da eseguire
 } while (parent->_closeThread==false);
 return 0;
}
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
RunnerThread::RunnerThread()
: _thread(0)
{}
RunnerThread::~RunnerThread()
{}
//////////////////////////////////////////////////////////////////////
// operations
bool RunnerThread::Open()
{
 ASSERT(_thread==0);
 _thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadFunction,
this, 0, &_thread_id);
 _closeThread = false;
 return true;
}
bool RunnerThread::Close()
{
 ASSERT(_thread!=0);
 _closeThread = true;
 WaitForSingleObject(_thread, 5000/*dipende dalla lunghezza delle operazioni
nel ciclo del thread*/);
 CloseHandle(_thread);
 _thread = 0;
 return true;
}