Newsgroup: it.comp.programmare.win32
Titolo: Info su _beingthread

Ciao a tutti,
sono nuovo al NG ed alla programmazione in windows.
Vorrei un chiarimento sulla funzione CreateThread e _beginthread, entrambe
creano un nuovo thread ma la seconda è da preferire se il thread richiama
funzioni di lib C (da MSDN).
Qualcuno di voi conosce il motivo per cui sussiste questo problema ?
Qualcosa a che vedere con malloc (calloc ecc) oppure no ?
Grazie

 Qualcosa a che vedere con malloc (calloc ecc) oppure no ?
_beginthreadex (meglio usare quest'ultima) si preoccupa della
inizializzazione e rimozione di strutture per la chiamata a CreateThread.
NON DEVI MAI RICHIAMARE CREATETHREAD. La non corretta inizializzazione può
mandare in abort tutto il processo.
--
  Jerle Shannara
Per rispondere in email togli JERLEANTISPAM
homepage 
http://utenti.tripod.it/jerleshannara

 ha scritto:
|
| _beginthreadex (meglio usare quest'ultima) si preoccupa della
| inizializzazione e rimozione di strutture per la chiamata a CreateThread.
| NON DEVI MAI RICHIAMARE CREATETHREAD. La non corretta inizializzazione puň
| mandare in abort tutto il processo.
|
| --
|   Jerle Shannara
| Per rispondere in email togli JERLEANTISPAM
| homepage 
http://utenti.tripod.it/jerleshannara
Ok, io parlavo di _beginthread e non la versione ex perchč chiudendo
automaticamente l'handle e non utilizzando i parametri aggiuntivi mi
risultava piů comoda
ma pensando ad una chiamata tipo
CreateThread ( NULL, 0, funzione, NULL, 0, &threadid )
non riesco a spiegarmi quali tipi di strutture particolari debbano essere
inizializzate, considerando che stando a MSDN se nel thread non uso funzioni
di libreria non dovrei aver problemi.
Se mi sai dare ulteriori info, queste sono ben volute.
Grazie
Giuly

 ? Qualcosa a che vedere con malloc (calloc ecc) oppure no ?
_beginthread, anzichè iniziare il thread dalla funzione che specifichi
tu, lo inizia un po' prima, in una funzione che inizializza i dati di
rientranza del nuovo thread (ad esempio l'errno), e poi chiama la tua
funzione. Tu usa sempre _beginthread, è molto meglio. Se richiamassi
funzioni della libreria C in un thread creato con CreateThread, la
prima funzione che cercasse di scrivere su errno andrebbe in crash.
Inoltre ad un thread creato con CreateThread non arrivano i segnali
Se sei curiosa su cosa faccia esattamente e se la tua versione di Visual
C++ non contiene i sorgenti della runtime C, sono inclusi nell'ultimo
PSDK, scaricabile gratuitamente. Ti riporto il codice di _beginthread
(tolti un po' di commenti), dal file thread.c:
"[...]
uintptr_t __cdecl _beginthread (
        void (__cdecl * initialcode) (void *),
        unsigned stacksize,
        void * argument
        )
{
        _ptiddata ptd;                  /* pointer to per-thread data */
        uintptr_t thdl;                 /* thread handle */
        unsigned long errcode = 0L;     /* Return from GetLastError() */
        if ( initialcode == NULL ) {
            errno = EINVAL;
            return( (uintptr_t)(-1) );
        }
        /*
         * Allocate and initialize a per-thread data structure for the to-
         * be-created thread.
         */
        if ( (ptd = _calloc_crt(1, sizeof(struct _tiddata))) == NULL )
                goto error_return;
        /*
         * Initialize the per-thread data
         */
        _initptd(ptd);
        ptd->_initaddr = (void *) initialcode;
        ptd->_initarg = argument;
        /*
         * Create the new thread. Bring it up in a suspended state so that
         * the _thandle and _tid fields are filled in before execution
         * starts.
         */
        if ( (ptd->_thandle = thdl = (uintptr_t)
              CreateThread( NULL,
                            stacksize,
                            _threadstart,
                            (LPVOID)ptd,
                            CREATE_SUSPENDED,
                            (LPDWORD)&(ptd->_tid) ))
             == (uintptr_t)0 )
        {
                errcode = GetLastError();
                goto error_return;
        }
        /*
         * Start the new thread executing
         */
        if ( ResumeThread( (HANDLE)thdl ) == (DWORD)(-1) ) {
                errcode = GetLastError();
                goto error_return;
        }
        /*
         * Good return
         */
        return(thdl);
        /*
         * Error return
         */
error_return:
        /*
         * Either ptd is NULL, or it points to the no-longer-necessary block
         * calloc-ed for the _tiddata struct which should now be freed up.
         */
        _free_crt(ptd);
        /*
         * Map the error, if necessary.
         */
        if ( errcode != 0L )
                _dosmaperr(errcode);
        return( (uintptr_t)(-1) );
}
[...]"
-- 
 < 
http://www.reactos.com/
 >  Open source clone of Windows NT. Current
     Don't stand, REACT!      version 0.0.20. C, C++ and ASM developers
                              and beta testers are welcome!

 ha scritto nel messaggio
news:Xns929CDB6...@127.0.0.1...
| Se sei curiosa su cosa faccia esattamente e se la tua versione di Visual
 curiosa !?!?!?!? forse č meglio *curioso* :-)
Per il resto, avevo provato con il debugger, ma con il sorgente č molto piů
chiaro.
Molte grazie
Giuly

  curiosa !?!?!?!? forse č meglio *curioso* :-)
scusa, eh, ma ti chiami "Giuly", io che devo pensare? :-P


 scusa, eh, ma ti chiami "Giuly", io che devo pensare? :-P
Alč.
Kiuhnm

 Alč.
zitto tu
